awesome-agents 0.1.5 → 0.1.8

package/src/renderers.js

@@ -1,7 +1,7 @@
 import crypto from "node:crypto";
 import os from "node:os";
 import path from "node:path";
-import { AGENT_ALIASES, DEFAULT_AGENT, GENERATED_MARKER, SUPPORTED_AGENTS } from "./constants.js";
+import { AGENT_ALIASES, GENERATED_MARKER, SUPPORTED_AGENTS } from "./constants.js";
 import { stringifyFrontmatter } from "./frontmatter.js";
 import { expandHome } from "./source.js";
 
@@ -20,8 +20,7 @@ export function normalizeAgentList(input, options = {}) {
 
   const rawAgents = flattenValues(input);
   if (rawAgents.length === 0) {
-    const fallback = arrayify(options.defaultAgent);
-    return fallback.length > 0 ? fallback : [DEFAULT_AGENT];
+    return arrayify(options.defaultAgent);
   }
 
   if (rawAgents.includes("*")) {
@@ -42,6 +41,12 @@ export function renderForAgent(profile, agent, context) {
   if (normalized === "opencode") {
     return renderOpenCode(profile, context);
   }
+  if (normalized === "goose") {
+    return renderGoose(profile, context);
+  }
+  if (normalized === "tenex-edge") {
+    return renderTenexEdge(profile, context);
+  }
   throw new Error(`Unsupported agent "${agent}"`);
 }
 
@@ -86,6 +91,28 @@ export function resolveTargetPath(profile, agent, options = {}) {
     return path.join(opencodeHome, "agents", `${profile.slug}.md`);
   }
 
+  if (normalized === "goose") {
+    if (scope === "project") {
+      return path.join(cwd, ".agents", "agents", `${profile.slug}.md`);
+    }
+
+    const gooseHome = options.gooseHome
+      ? path.resolve(expandHome(options.gooseHome, home))
+      : process.env.GOOSE_HOME
+        ? path.resolve(expandHome(process.env.GOOSE_HOME, home))
+        : path.join(home, ".agents");
+    return path.join(gooseHome, "agents", `${profile.slug}.md`);
+  }
+
+  if (normalized === "tenex-edge") {
+    const tenexEdgeHome = options.tenexEdgeHome
+      ? path.resolve(expandHome(options.tenexEdgeHome, home))
+      : process.env.TENEX_EDGE_HOME
+        ? path.resolve(expandHome(process.env.TENEX_EDGE_HOME, home))
+        : path.join(home, ".tenex-edge");
+    return path.join(tenexEdgeHome, "agents", `${profile.slug}.json`);
+  }
+
   throw new Error(`Unsupported agent "${agent}"`);
 }
 
@@ -160,6 +187,98 @@ function renderOpenCode(profile, context) {
   return stringifyFrontmatter(attributes, `${marker}\n\n${buildInstructionBody(profile, undefined, "opencode")}`);
 }
 
+function renderGoose(profile, context) {
+  const attributes = {
+    name: profile.slug,
+    description: profile.summary || profile.name
+  };
+  const model = chooseGooseModel(profile);
+  if (model && model !== "inherit") {
+    attributes.model = model;
+  }
+
+  const marker = htmlMarker(profile, "goose", context);
+  return stringifyFrontmatter(attributes, `${marker}\n\n${buildInstructionBody(profile, profile.adapters.goose ?? profile.adapters["claude-code"], "goose")}`);
+}
+
+function renderTenexEdge(profile, context) {
+  const existing = tenexEdgeKeyMaterial(context.existingContent);
+  const keyMaterial = existing ?? generateNostrKeypair();
+  const commands = tenexEdgeCommands(profile, context);
+  const agent = tenexEdgeInlineAgent(profile);
+
+  const stored = {
+    slug: profile.slug,
+    secret_key: keyMaterial.secret_key,
+    public_key: keyMaterial.public_key,
+    created_at: keyMaterial.created_at ?? Math.floor(Date.now() / 1000),
+    commands,
+    byline: profile.summary || profile.name,
+    managed_by: GENERATED_MARKER,
+    source: context.source
+  };
+
+  if (hasInlineClaudeCommand(commands)) {
+    stored.agent = agent;
+  }
+
+  return `${JSON.stringify(stored, null, 2)}\n`;
+}
+
+function tenexEdgeInlineAgent(profile) {
+  const agent = {
+    description: profile.summary || profile.name,
+    prompt: buildInstructionBody(profile, profile.adapters["tenex-edge"] ?? profile.adapters["claude-code"], "tenex-edge")
+  };
+  const model = chooseClaudeModel(profile);
+  const effort = profile.attributes.recommended_reasoning_effort;
+
+  if (model && model !== "inherit") {
+    agent.model = model;
+  }
+  if (effort && effort !== "inherit" && ["low", "medium", "high", "xhigh", "max"].includes(effort)) {
+    agent.effort = effort;
+  }
+
+  return agent;
+}
+
+function tenexEdgeCommands(profile, context) {
+  const commands = [];
+  for (const harness of arrayify(context.selectedHarnesses)) {
+    if (harness === "codex") {
+      commands.push({
+        name: "codex",
+        argv: ["codex", "--profile", profile.slug]
+      });
+    } else if (harness === "claude-code") {
+      commands.push({
+        name: "claude",
+        argv: ["claude", "--agent", profile.slug]
+      });
+    }
+  }
+
+  // Keep tenex-edge-only installs self-contained. tenex-edge expands this with
+  // the inline `agent` definition as `claude --agents ... --agent <slug>`.
+  if (!commands.some((command) => command.name === "claude")) {
+    commands.push({
+      name: "claude",
+      argv: ["claude"]
+    });
+  }
+
+  return uniqueBy(commands, (command) => command.name);
+}
+
+function hasInlineClaudeCommand(commands) {
+  return commands.some((command) => (
+    command.name === "claude" &&
+    command.argv.length === 1 &&
+    command.argv[0] === "claude"
+  ));
+}
+
 function buildInstructionBody(profile, adapter, harness) {
   const parts = [
     profile.body.trimEnd(),
@@ -174,6 +293,20 @@ function buildInstructionBody(profile, adapter, harness) {
     "- The runtime agent manages any profile-specific home directory and notes at task time."
   ];
 
+  if (profile.installedSkills?.length) {
+    const skillBase = path.join(path.dirname(profile.installedSkills[0].path), "<skill>");
+    parts.push(
+      "",
+      "## Immediately Relevant Skills",
+      "",
+      `Immediately relevant skills; you should load these right away from \`${skillBase}\`.`,
+      ""
+    );
+    for (const skill of profile.installedSkills) {
+      parts.push(`- \`${skill.name}\`: \`${skill.path}\``);
+    }
+  }
+
   if (adapter?.body) {
     parts.push("", "## Harness Adapter", "", adapter.body.trimEnd());
   }
@@ -220,6 +353,78 @@ function chooseOpenCodeModel(profile) {
   return candidates.find((model) => model.includes("/"));
 }
 
+function chooseGooseModel(profile) {
+  const candidates = [
+    profile.attributes.recommended_model,
+    ...arrayify(profile.attributes.recommended_models)
+  ].filter(Boolean).map((value) => String(value).toLowerCase());
+
+  if (candidates.some((model) => model.includes("opus"))) {
+    return "claude-3-5-sonnet";
+  }
+  if (candidates.some((model) => model.includes("sonnet"))) {
+    return "claude-3-5-sonnet";
+  }
+  if (candidates.some((model) => model.includes("haiku"))) {
+    return "claude-3-5-haiku";
+  }
+  if (candidates.some((model) => model.includes("gpt"))) {
+    return candidates.find((model) => model.includes("gpt"));
+  }
+  return undefined;
+}
+
+function tenexEdgeKeyMaterial(content) {
+  if (!content) {
+    return undefined;
+  }
+
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return undefined;
+  }
+
+  if (!isHex64(parsed.secret_key)) {
+    return undefined;
+  }
+
+  const derived = derivePublicKey(parsed.secret_key);
+  if (!derived) {
+    return undefined;
+  }
+
+  return {
+    secret_key: parsed.secret_key,
+    public_key: isHex64(parsed.public_key) ? parsed.public_key : derived,
+    created_at: Number.isInteger(parsed.created_at) ? parsed.created_at : undefined
+  };
+}
+
+function generateNostrKeypair() {
+  const ecdh = crypto.createECDH("secp256k1");
+  const publicKey = ecdh.generateKeys(undefined, "uncompressed");
+  return {
+    secret_key: ecdh.getPrivateKey("hex"),
+    public_key: publicKey.subarray(1, 33).toString("hex")
+  };
+}
+
+function derivePublicKey(secretKey) {
+  try {
+    const ecdh = crypto.createECDH("secp256k1");
+    ecdh.setPrivateKey(Buffer.from(secretKey, "hex"));
+    return ecdh.getPublicKey(undefined, "uncompressed").subarray(1, 33).toString("hex");
+  } catch {
+    return undefined;
+  }
+}
+
+function isHex64(value) {
+  return typeof value === "string" && /^[0-9a-fA-F]{64}$/.test(value);
+}
+
 function tomlString(value) {
   return JSON.stringify(String(value));
 }
@@ -250,6 +455,20 @@ function arrayify(value) {
   return [value];
 }
 
+function uniqueBy(values, keyForValue) {
+  const seen = new Set();
+  const out = [];
+  for (const value of values) {
+    const key = keyForValue(value);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    out.push(value);
+  }
+  return out;
+}
+
 function flattenValues(values) {
   return arrayify(values)
     .flatMap((value) => String(value).split(","))

package/src/skills.js

@@ -0,0 +1,397 @@
+import { existsSync } from "node:fs";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { parseFrontmatter } from "./frontmatter.js";
+import { expandHome, materializeSource } from "./source.js";
+
+const SKILL_CONTAINER_DIRS = [
+  "skills",
+  "skills/.curated",
+  "skills/.experimental",
+  "skills/.system",
+  ".agents/skills",
+  ".claude/skills",
+  ".codex/skills",
+  ".opencode/skills"
+];
+const SKIP_DIRS = new Set([".git", "node_modules", "dist", "build", "__pycache__"]);
+
+export async function installProfileSkills(profile, sourceRoot, options = {}) {
+  const dependencies = normalizeSkillDependencies(profile.attributes.skills);
+  if (dependencies.length === 0) {
+    return [];
+  }
+
+  const home = path.resolve(expandHome(options.home ?? os.homedir()));
+  const installed = [];
+
+  for (const dependency of dependencies) {
+    const skill = await resolveSkillDependency(profile, dependency, sourceRoot, home, options);
+    const target = path.join(home, ".agents", "homes", profile.slug, "skills", skill.installName);
+
+    if (!options.dryRun) {
+      await fs.rm(target, { recursive: true, force: true });
+      await fs.mkdir(path.dirname(target), { recursive: true });
+      await fs.cp(skill.path, target, {
+        recursive: true,
+        dereference: true,
+        preserveTimestamps: true
+      });
+    }
+
+    installed.push({
+      name: skill.installName,
+      declaredName: dependency.selector ?? dependency.source ?? skill.name,
+      source: skill.source,
+      sourceKind: skill.sourceKind,
+      path: target
+    });
+  }
+
+  return installed;
+}
+
+function normalizeSkillDependencies(value) {
+  if (!value) {
+    return [];
+  }
+
+  const entries = Array.isArray(value) ? value : [value];
+  return entries.map(parseSkillDependency);
+}
+
+function parseSkillDependency(value) {
+  if (typeof value === "string") {
+    const text = value.trim();
+    if (!text) {
+      throw new Error("Skill dependency entries must not be empty.");
+    }
+
+    const split = text.match(/^(\S+)\s+(.+)$/);
+    if (split) {
+      return { source: split[1], selector: split[2].trim(), raw: text };
+    }
+
+    const atSelector = splitAtSelector(text);
+    if (atSelector) {
+      return { source: atSelector.source, selector: atSelector.selector, raw: text };
+    }
+
+    if (looksLikeRemoteSource(text)) {
+      return { source: text, selector: undefined, raw: text };
+    }
+
+    return { selector: text, raw: text };
+  }
+
+  if (isObject(value)) {
+    const source = firstString(value.source, value.package, value.repository, value.repo);
+    const selector = firstString(value.skill, value.name, value.slug, value.id);
+    if (!source && !selector) {
+      throw new Error("Skill dependency objects must include a skill/name or source field.");
+    }
+    return { source, selector, raw: value };
+  }
+
+  throw new Error("Skill dependencies must be strings or objects.");
+}
+
+function splitAtSelector(value) {
+  if (value.startsWith("git@")) {
+    return undefined;
+  }
+  const atIndex = value.lastIndexOf("@");
+  if (atIndex <= 0 || atIndex === value.length - 1 || atIndex <= value.lastIndexOf("/")) {
+    return undefined;
+  }
+  return {
+    source: value.slice(0, atIndex),
+    selector: value.slice(atIndex + 1)
+  };
+}
+
+function looksLikeRemoteSource(value) {
+  return value.includes("/") || value.includes(":") || value.startsWith("~") || value.startsWith(".");
+}
+
+async function resolveSkillDependency(profile, dependency, sourceRoot, home, options) {
+  if (dependency.source) {
+    const materialized = await materializeSource(dependency.source, {
+      ...options,
+      requireAgentProfileLayout: false
+    });
+    try {
+      return await selectSkillFromRoot(materialized.path, dependency.selector, {
+        dependency,
+        source: materialized.source,
+        sourceKind: materialized.kind
+      });
+    } finally {
+      await materialized.cleanup();
+    }
+  }
+
+  const profileSkill = await findSkillInRoot(profile.agentRoot, dependency.selector, {
+    dependency,
+    source: profile.agentRoot,
+    sourceKind: "profile-local"
+  });
+  if (profileSkill) {
+    return profileSkill;
+  }
+
+  const sourceSkill = await findSkillInRoot(sourceRoot, dependency.selector, {
+    dependency,
+    source: sourceRoot,
+    sourceKind: "local-source"
+  });
+  if (sourceSkill) {
+    return sourceSkill;
+  }
+
+  const userSkillRoot = path.join(home, ".agents", "skills");
+  const userSkill = await findSkillInRoot(userSkillRoot, dependency.selector, {
+    dependency,
+    source: userSkillRoot,
+    sourceKind: "user-skills"
+  });
+  if (userSkill) {
+    return userSkill;
+  }
+
+  throw new Error(`Skill "${dependency.selector}" was not found in the profile source or ${userSkillRoot}.`);
+}
+
+async function findSkillInRoot(root, selector, context) {
+  if (!root || !existsSync(root)) {
+    return undefined;
+  }
+
+  const skills = await discoverSkills(root);
+  if (skills.length === 0) {
+    return undefined;
+  }
+
+  return findDiscoveredSkill(skills, selector, context);
+}
+
+async function selectSkillFromRoot(root, selector, context) {
+  const skills = await discoverSkills(root);
+  if (skills.length === 0) {
+    throw new Error(`No skills found in ${context.source}. Expected SKILL.md files in the source root or skills/<name>/.`);
+  }
+
+  return selectDiscoveredSkill(skills, selector, context);
+}
+
+function selectDiscoveredSkill(skills, selector, context) {
+  if (!selector) {
+    if (skills.length === 1) {
+      return withSource(skills[0], context);
+    }
+    throw new Error(`Skill source "${context.source}" contains multiple skills. Specify one of: ${skills.map((skill) => skill.name).join(", ")}`);
+  }
+
+  const normalized = sanitizeSkillName(selector);
+  const selected = skills.find((skill) => {
+    return sanitizeSkillName(skill.name) === normalized
+      || sanitizeSkillName(skill.directoryName) === normalized
+      || skill.installName === normalized;
+  });
+
+  if (!selected) {
+    throw new Error(`Skill "${selector}" was not found in ${context.source}. Available skills: ${skills.map((skill) => skill.name).join(", ")}`);
+  }
+
+  return withSource(selected, context);
+}
+
+function findDiscoveredSkill(skills, selector, context) {
+  if (!selector) {
+    return skills.length === 1 ? withSource(skills[0], context) : undefined;
+  }
+
+  const normalized = sanitizeSkillName(selector);
+  const selected = skills.find((skill) => {
+    return sanitizeSkillName(skill.name) === normalized
+      || sanitizeSkillName(skill.directoryName) === normalized
+      || skill.installName === normalized;
+  });
+
+  return selected ? withSource(selected, context) : undefined;
+}
+
+function withSource(skill, context) {
+  return {
+    ...skill,
+    source: context.source,
+    sourceKind: context.sourceKind
+  };
+}
+
+async function discoverSkills(root) {
+  const discovered = [];
+  const seenPaths = new Set();
+  const seenNames = new Set();
+
+  const addSkillAt = async (skillDir) => {
+    const skillPath = path.join(skillDir, "SKILL.md");
+    if (!existsSync(skillPath)) {
+      return false;
+    }
+
+    const resolved = path.resolve(skillDir);
+    if (seenPaths.has(resolved)) {
+      return true;
+    }
+
+    const skill = await readSkill(skillDir, root);
+    if (seenNames.has(skill.installName)) {
+      return true;
+    }
+
+    discovered.push(skill);
+    seenPaths.add(resolved);
+    seenNames.add(skill.installName);
+    return true;
+  };
+
+  await addSkillAt(root);
+  await discoverContainer(root, false, addSkillAt);
+  for (const container of SKILL_CONTAINER_DIRS) {
+    await discoverContainer(path.join(root, container), true, addSkillAt);
+  }
+
+  if (discovered.length === 0) {
+    for (const skillDir of await findSkillDirs(root)) {
+      await addSkillAt(skillDir);
+    }
+  }
+
+  return discovered.sort((a, b) => a.installName.localeCompare(b.installName));
+}
+
+async function discoverContainer(container, walkGrandchildren, addSkillAt) {
+  let entries;
+  try {
+    entries = await fs.readdir(container, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    if (SKIP_DIRS.has(entry.name)) {
+      continue;
+    }
+
+    const childDir = path.join(container, entry.name);
+    if (!await isDirectoryLike(entry, childDir)) {
+      continue;
+    }
+
+    const found = await addSkillAt(childDir);
+    if (found || !walkGrandchildren) {
+      continue;
+    }
+
+    let grandchildren;
+    try {
+      grandchildren = await fs.readdir(childDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const grandchild of grandchildren) {
+      if (SKIP_DIRS.has(grandchild.name)) {
+        continue;
+      }
+      const grandchildDir = path.join(childDir, grandchild.name);
+      if (await isDirectoryLike(grandchild, grandchildDir)) {
+        await addSkillAt(grandchildDir);
+      }
+    }
+  }
+}
+
+async function findSkillDirs(root) {
+  const results = [];
+
+  async function visit(directory) {
+    let entries;
+    try {
+      entries = await fs.readdir(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    if (existsSync(path.join(directory, "SKILL.md"))) {
+      results.push(directory);
+      return;
+    }
+
+    for (const entry of entries) {
+      if (SKIP_DIRS.has(entry.name)) {
+        continue;
+      }
+      const entryPath = path.join(directory, entry.name);
+      if (await isDirectoryLike(entry, entryPath)) {
+        await visit(entryPath);
+      }
+    }
+  }
+
+  await visit(root);
+  return results;
+}
+
+async function readSkill(skillDir, root) {
+  const skillPath = path.join(skillDir, "SKILL.md");
+  const raw = await fs.readFile(skillPath, "utf8");
+  const parsed = parseFrontmatter(raw, skillPath);
+  const directoryName = path.basename(skillDir);
+  const name = firstString(parsed.attributes.name, directoryName);
+
+  return {
+    name,
+    installName: sanitizeSkillName(name),
+    directoryName,
+    path: skillDir,
+    relativePath: path.relative(root, skillDir)
+  };
+}
+
+async function isDirectoryLike(entry, entryPath) {
+  if (entry.isDirectory()) {
+    return true;
+  }
+  if (!entry.isSymbolicLink()) {
+    return false;
+  }
+
+  try {
+    return (await fs.stat(entryPath)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function sanitizeSkillName(name) {
+  return String(name)
+    .toLowerCase()
+    .replace(/[^a-z0-9._]+/g, "-")
+    .replace(/^[.-]+|[.-]+$/g, "")
+    .slice(0, 255) || "unnamed-skill";
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return "";
+}
+
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}