awesome-agents 0.1.5 → 0.1.6

package/src/help.js

@@ -188,13 +188,13 @@ const banner = [
   color("                       | (_| | (_| |  __/ | | | |_\\__ \\  ", codes.bannerB),
   color("                        \\__,_|\\__, |\\___|_| |_|\\__|___/  ", codes.bannerA),
   color("                              |___/                       ", codes.bannerA),
-  `  ${ui.dim("Operational profiles for Codex, Claude Code, and OpenCode")}`
+  `  ${ui.dim("Operational profiles for Codex, Claude Code, OpenCode, and tenex-edge")}`
 ];
 
 const mainHelp = {
   banner,
   usage: `${PACKAGE_NAME} <command> [options]`,
-  description: "Install reusable operational agent profiles into Codex, Claude Code, and OpenCode.",
+  description: "Install reusable operational agent profiles into Codex, Claude Code, OpenCode, and tenex-edge.",
   sections: [
     {
       title: "Manage Profiles:",
@@ -270,7 +270,7 @@ const mainHelp = {
   examples: [
     { command: `${PACKAGE_NAME} add ${exampleSource} --list`, comment: "inspect source profiles" },
     { command: `${PACKAGE_NAME} add ${exampleSource} --agent ${exampleProfile}` },
-    { command: `${PACKAGE_NAME} add ${exampleSource} --agent ${exampleProfile} --harness opencode` },
+    { command: `${PACKAGE_NAME} add ${exampleSource} --agent ${exampleProfile} --harness tenex-edge` },
     { command: `${PACKAGE_NAME} add ${exampleSource} --all --dry-run`, comment: "preview every write" },
     { command: `${PACKAGE_NAME} use ${exampleSource}@${exampleProfile} --harness claude-code` },
     { command: `${PACKAGE_NAME} list --json`, comment: "machine-readable output" },
@@ -289,8 +289,8 @@ const commandHelp = {
         title: "Install Flow:",
         rows: [
           "1. Read canonical definitions from agents/<slug>/agent.yaml or compatible variants.",
-          "2. Install agent-owned scripts and references into ~/.agents/homes/<slug>/.",
-          "3. Render Codex, Claude Code, or OpenCode files and record them in the registry."
+          "2. Install agent-owned scripts, references, and declared skills into ~/.agents/homes/<slug>/.",
+          "3. Render Codex, Claude Code, OpenCode, or tenex-edge files and record them in the registry."
         ]
       },
       {
@@ -308,6 +308,7 @@ const commandHelp = {
           { term: ui.option("--agent triage-agent"), description: "Preferred shorthand: install one profile slug" },
           { term: ui.option("--profile triage-agent"), description: "Explicit profile selector" },
           { term: ui.option("--skill triage-agent"), description: "Compatibility alias for --profile" },
+          { term: ui.option("(interactive)"), description: "Without a profile selector, choose source profiles from a checkbox list" },
           { term: ui.option("--all"), description: "Install every source profile" },
           { term: ui.option("--list"), description: "Show available profiles and exit" }
         ]
@@ -315,9 +316,9 @@ const commandHelp = {
       {
         title: "Choose Targets:",
         rows: [
-          { term: ui.option("(default)"), description: "Every harness detected on PATH (codex, claude, opencode); falls back to Codex if none are found" },
+          { term: ui.option("(auto-detect)"), description: "Every harness detected on PATH; interactive multi-detect opens a checked selector; pass --harness when none are detected" },
           { term: ui.option("--harness opencode"), description: "Render for one harness" },
-          { term: ui.option("--harness codex claude-code"), description: "Render for multiple harnesses" },
+          { term: ui.option("--harness codex tenex-edge"), description: "Render for multiple harnesses" },
           { term: ui.option("--harness *"), description: "Render for every supported harness" },
           { term: ui.option("--global"), description: "Install into the user-level harness directory" },
           { term: ui.option("--project"), description: "Install project-local files where the harness supports it" }
@@ -329,6 +330,7 @@ const commandHelp = {
           { term: ui.command("codex"), description: `${ui.path("~/.codex/<profile>.config.toml")} (project-local Codex profiles are not supported)` },
           { term: ui.command("claude-code"), description: `${ui.path("~/.claude/agents/<profile>.md")} or ${ui.path(".claude/agents/<profile>.md")}` },
           { term: ui.command("opencode"), description: `${ui.path("~/.config/opencode/agents/<profile>.md")} or ${ui.path(".opencode/agents/<profile>.md")}` },
+          { term: ui.command("tenex-edge"), description: `${ui.path("~/.tenex-edge/agents/<profile>.json")} (project-local tenex-edge agents are not supported)` },
           { term: ui.command("registry"), description: `${ui.path("~/.awesome-agents/installed.json")} or ${ui.path(".awesome-agents/installed.json")}` }
         ]
       },
@@ -346,7 +348,7 @@ const commandHelp = {
     examples: [
       { command: `${PACKAGE_NAME} add ${exampleSource} --list` },
       { command: `${PACKAGE_NAME} add ${exampleSource} --agent ${exampleProfile}` },
-      { command: `${PACKAGE_NAME} add ${exampleSource} --agent ${exampleProfile} --harness codex opencode` },
+      { command: `${PACKAGE_NAME} add ${exampleSource} --agent ${exampleProfile} --harness codex tenex-edge` },
       { command: `${PACKAGE_NAME} add ${exampleSource} --all --dry-run` }
     ],
     footer: `Generated files are marked with ${ui.profile("Generated by awesome-agents")}.`
@@ -449,14 +451,14 @@ const commandHelp = {
 function installOptions({ includeHome = false } = {}) {
   return compact([
     { term: ui.option("-g, --global"), description: "Install globally instead of into the current project" },
-    { term: ui.option("-p, --project"), description: "Install into the current project; not supported for Codex profiles" },
+    { term: ui.option("-p, --project"), description: "Install into the current project; not supported for Codex or tenex-edge profiles" },
     { term: ui.option("-a, --agent <profiles...>"), description: "Select agent profile slugs; harness names still work for compatibility" },
     { term: ui.option("--harness <harnesses...>"), description: `Select target harnesses: ${harnesses}, or *` },
     { term: ui.option("-s, --profile <profiles...>"), description: "Explicit profile selector; accepts *" },
     { term: ui.option("--skill <profiles...>"), description: "Compatibility alias for --profile" },
     { term: ui.option("-l, --list"), description: "List available source profiles without installing" },
     { term: ui.option("--all"), description: "Install all profiles to all supported harnesses" },
-    { term: ui.option("-y, --yes"), description: "Accepted for npx skills parity; prompts are not used" },
+    { term: ui.option("-y, --yes"), description: "Accept detected profile and harness selections without opening selectors" },
     { term: ui.option("--dry-run"), description: "Print planned installs without writing files" },
     { term: ui.option("--force"), description: "Allow overwriting files without the generated marker" },
     { term: ui.option("--json"), description: "Output JSON without ANSI color" },

package/src/installer.js

@@ -6,6 +6,7 @@ import { AGENT_ALIASES, HARNESS_COMMANDS, SUPPORTED_AGENTS } from "./constants.j
 import { contentHash, isGeneratedContent, normalizeAgentList, renderForAgent, resolveTargetPath } from "./renderers.js";
 import { expandHome, loadCatalog, materializeSource, splitSourceSpec } from "./source.js";
 import { readRegistry, registryPath, removeInstall, upsertInstall, writeRegistry } from "./registry.js";
+import { installProfileSkills } from "./skills.js";
 
 export async function listAvailable(sourceInput, options = {}) {
   const { source } = splitSourceSpec(sourceInput);
@@ -22,16 +23,13 @@ export async function installFromSource(sourceSpec, options = {}) {
   const split = splitSourceSpec(sourceSpec);
   const source = split.source;
   const { selectors, harnessInput } = resolveInstallSelection(split, options);
-  const harnesses = normalizeAgentList(harnessInput, {
-    all: options.all,
-    defaultAgent: detectAvailableHarnesses()
-  });
+  const harnesses = await resolveHarnessesForInstall(harnessInput, options);
   const scope = resolveScope(options, harnesses);
 
   const materialized = await materializeSource(source, options);
   try {
     const catalog = await loadCatalog(materialized.path);
-    const profiles = selectProfiles(catalog.profiles, selectors, options.all);
+    const profiles = await resolveProfilesForInstall(catalog.profiles, selectors, options.all, options.chooseProfiles, materialized.source);
     const registryOptions = { ...options, scope };
     const registry = await readRegistry(registryOptions);
     const operations = [];
@@ -39,9 +37,18 @@ export async function installFromSource(sourceSpec, options = {}) {
 
     for (const profile of profiles) {
       const supportTargets = await installProfileSupport(profile, options);
+      const installedSkills = await installProfileSkills(profile, materialized.path, options);
+      const renderProfile = {
+        ...profile,
+        installedSkills
+      };
       for (const harness of harnesses) {
-        const content = renderForAgent(profile, harness, { source: materialized.source });
-        const target = resolveTargetPath(profile, harness, { ...options, scope });
+        const target = resolveTargetPath(renderProfile, harness, { ...options, scope });
+        const existingContent = await readExistingContent(target);
+        const content = renderForAgent(renderProfile, harness, {
+          source: materialized.source,
+          existingContent
+        });
         await writeManagedFile(target, content, options);
 
         const install = {
@@ -56,6 +63,8 @@ export async function installFromSource(sourceSpec, options = {}) {
           installedAt,
           contentSha256: contentHash(content),
           supportTargets,
+          skillTargets: installedSkills.map((skill) => skill.path),
+          installedSkills,
           dryRun: Boolean(options.dryRun)
         };
 
@@ -91,9 +100,7 @@ export async function useFromSource(sourceSpec, options = {}) {
     throw new Error("Specify a profile with source@profile or --profile <profile>.");
   }
 
-  const harness = normalizeAgentList(harnessInput, {
-    defaultAgent: detectAvailableHarnesses()
-  })[0];
+  const harness = resolveHarnessForUse(harnessInput, options);
   const materialized = await materializeSource(split.source, options);
   try {
     const catalog = await loadCatalog(materialized.path);
@@ -311,6 +318,8 @@ function runInstructionForOperation(operation, env) {
     }
     return {
       profile: operation.profile,
+      name: operation.name,
+      summary: operation.summary,
       harness: operation.harness,
       command: `codex --profile ${shellWord(operation.profile)}`,
       note: "Starts Codex with this installed profile."
@@ -323,6 +332,8 @@ function runInstructionForOperation(operation, env) {
     }
     return {
       profile: operation.profile,
+      name: operation.name,
+      summary: operation.summary,
       harness: operation.harness,
       command: `claude --agent ${shellWord(operation.profile)}`,
       note: "Starts Claude Code with this installed agent profile."
@@ -335,19 +346,77 @@ function runInstructionForOperation(operation, env) {
     }
     return {
       profile: operation.profile,
+      name: operation.name,
+      summary: operation.summary,
       harness: operation.harness,
       command: "opencode",
       note: `Start OpenCode, then invoke @${operation.profile} in the session.`
     };
   }
 
+  if (operation.harness === "tenex-edge") {
+    if (!commandExists("tenex-edge", env)) {
+      return undefined;
+    }
+    return {
+      profile: operation.profile,
+      name: operation.name,
+      summary: operation.summary,
+      harness: operation.harness,
+      command: `tenex-edge launch ${shellWord(operation.profile)}`,
+      note: "Starts this profile as a tenex-edge-managed Claude Code agent."
+    };
+  }
+
   return undefined;
 }
 
+async function resolveHarnessesForInstall(harnessInput, options = {}) {
+  if (options.all || harnessInput !== undefined) {
+    return normalizeAgentList(harnessInput, { all: options.all });
+  }
+
+  const detected = detectAvailableHarnesses(options.env ?? process.env);
+  if (detected.length === 0) {
+    throw new Error(noDetectedHarnessMessage());
+  }
+
+  if (detected.length > 1 && typeof options.chooseHarnesses === "function") {
+    const chosen = await options.chooseHarnesses(detected);
+    const harnesses = normalizeAgentList(chosen);
+    if (harnesses.length === 0) {
+      throw new Error("Select at least one harness to install, or pass --harness <harness>.");
+    }
+    return harnesses;
+  }
+
+  return detected;
+}
+
+function resolveHarnessForUse(harnessInput, options = {}) {
+  const explicit = normalizeAgentList(harnessInput);
+  if (explicit.length > 0) {
+    return explicit[0];
+  }
+
+  const detected = detectAvailableHarnesses(options.env ?? process.env);
+  if (detected.length === 0) {
+    throw new Error(noDetectedHarnessMessage());
+  }
+  if (detected.length > 1) {
+    throw new Error(`Multiple harnesses detected (${detected.join(", ")}). Pass --harness <harness> because use renders one target at a time.`);
+  }
+  return detected[0];
+}
+
 function detectAvailableHarnesses(env = process.env) {
   return SUPPORTED_AGENTS.filter((harness) => commandExists(HARNESS_COMMANDS.get(harness), env));
 }
 
+function noDetectedHarnessMessage() {
+  return `No supported harness CLI detected on PATH. Pass --harness <${SUPPORTED_AGENTS.join("|")}> to choose a target.`;
+}
+
 function commandExists(command, env) {
   const pathValue = env.PATH ?? "";
   if (!pathValue) {
@@ -372,6 +441,15 @@ function shellWord(value) {
   return `'${text.replaceAll("'", "'\\''")}'`;
 }
 
+async function resolveProfilesForInstall(profiles, selectors, all, chooseProfiles, source) {
+  if (!all && selectors.length === 0 && typeof chooseProfiles === "function") {
+    const chosen = await chooseProfiles(profiles.map((profile) => profileSummary(profile, source)));
+    return selectProfiles(profiles, normalizeProfileSelectors(chosen), false);
+  }
+
+  return selectProfiles(profiles, selectors, all);
+}
+
 function selectProfiles(profiles, selectors, all = false) {
   if (all || selectors.length === 0 || selectors.includes("*")) {
     return profiles;
@@ -406,6 +484,13 @@ async function writeManagedFile(target, content, options = {}) {
   await fs.writeFile(target, content);
 }
 
+async function readExistingContent(target) {
+  if (!existsSync(target)) {
+    return undefined;
+  }
+  return fs.readFile(target, "utf8");
+}
+
 function resolveScope(options = {}, harnesses = []) {
   if (options.project && options.global) {
     throw new Error("Use either --global or --project, not both.");
@@ -413,13 +498,16 @@ function resolveScope(options = {}, harnesses = []) {
   if (options.project && harnesses.includes("codex")) {
     throw new Error("Codex profiles are loaded from $CODEX_HOME/<name>.config.toml and cannot be installed project-locally. Use --global or choose a different harness.");
   }
+  if (options.project && harnesses.includes("tenex-edge")) {
+    throw new Error("tenex-edge agents are machine-local under $TENEX_EDGE_HOME/agents or ~/.tenex-edge/agents and cannot be installed project-locally. Use --global or choose a different harness.");
+  }
   if (options.global) {
     return "global";
   }
   if (options.project) {
     return "project";
   }
-  if (harnesses.includes("codex")) {
+  if (harnesses.includes("codex") || harnesses.includes("tenex-edge")) {
     return "global";
   }
   return "project";

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,9 @@ export function renderForAgent(profile, agent, context) {
   if (normalized === "opencode") {
     return renderOpenCode(profile, context);
   }
+  if (normalized === "tenex-edge") {
+    return renderTenexEdge(profile, context);
+  }
   throw new Error(`Unsupported agent "${agent}"`);
 }
 
@@ -86,6 +88,15 @@ export function resolveTargetPath(profile, agent, options = {}) {
     return path.join(opencodeHome, "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 +171,38 @@ function renderOpenCode(profile, context) {
   return stringifyFrontmatter(attributes, `${marker}\n\n${buildInstructionBody(profile, undefined, "opencode")}`);
 }
 
+function renderTenexEdge(profile, context) {
+  const existing = tenexEdgeKeyMaterial(context.existingContent);
+  const keyMaterial = existing ?? generateNostrKeypair();
+  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;
+  }
+
+  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),
+    command: ["claude"],
+    agent,
+    byline: profile.summary || profile.name,
+    managed_by: GENERATED_MARKER,
+    source: context.source
+  };
+
+  return `${JSON.stringify(stored, null, 2)}\n`;
+}
+
 function buildInstructionBody(profile, adapter, harness) {
   const parts = [
     profile.body.trimEnd(),
@@ -174,6 +217,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 +277,57 @@ function chooseOpenCodeModel(profile) {
   return candidates.find((model) => model.includes("/"));
 }
 
+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));
 }