@jstn-sdk/ma 0.1.13 → 0.14.0

package/scripts/setup-npmrc.js

@@ -1,39 +1,64 @@
 #!/usr/bin/env node
 
+import { randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import process from "node:process";
+import { fileURLToPath } from "node:url";
 
-function normalizeRegistry(registryUrl) {
-  return registryUrl.endsWith("/") ? registryUrl : `${registryUrl}/`;
+export async function createTemporaryNpmConfig({
+  token,
+  registry = "https://registry.npmjs.org/",
+  scope = "",
+  tempRoot = process.env.RUNNER_TEMP || os.tmpdir(),
+} = {}) {
+  if (!token) return null;
+  const normalizedRegistry = registry.endsWith("/") ? registry : `${registry}/`;
+  const host = new URL(normalizedRegistry).host;
+  const configPath = path.join(tempRoot, `meta-architect-npmrc-${randomUUID()}`);
+  const content = [
+    `registry=${normalizedRegistry}`,
+    ...(scope ? [`${scope}:registry=${normalizedRegistry}`] : []),
+    `//${host}/:_authToken=${token}`,
+    "",
+  ].join("\n");
+
+  await fs.writeFile(configPath, content, { encoding: "utf8", mode: 0o600 });
+  await fs.chmod(configPath, 0o600);
+  return configPath;
+}
+
+export async function cleanupTemporaryNpmConfig(configPath) {
+  if (!configPath) return false;
+  await fs.rm(configPath, { force: true });
+  return true;
 }
 
 async function main() {
   const token = process.env.NPM_TOKEN || process.env.NODE_AUTH_TOKEN;
   if (!token) {
-    console.log("No npm token detected. Skipping .npmrc generation.");
+    console.log("No npm token detected. Skipping temporary npm auth config.");
     return;
   }
 
-  const registry = normalizeRegistry(process.env.NPM_REGISTRY_URL || "https://registry.npmjs.org/");
-  const scope = process.env.NPM_SCOPE || "";
-  const host = new URL(registry).host;
-  const npmrcPath = path.join(process.cwd(), ".npmrc");
-
-  const content = [
-    `registry=${registry}`,
-    ...(scope ? [`${scope}:registry=${registry}`] : []),
-    `//${host}/:_authToken=${token}`,
-    "",
-  ].join("\n");
-
-  await fs.writeFile(npmrcPath, content, "utf8");
-  console.log(
-    `Wrote CI .npmrc for ${scope ? `scope ${scope}` : "the canonical unscoped package"}.`,
-  );
+  const configPath = await createTemporaryNpmConfig({
+    token,
+    registry: process.env.NPM_REGISTRY_URL || "https://registry.npmjs.org/",
+    scope: process.env.NPM_SCOPE || "",
+  });
+  if (process.env.GITHUB_ENV) {
+    await fs.appendFile(process.env.GITHUB_ENV, `NPM_CONFIG_USERCONFIG=${configPath}\n`);
+  }
+  console.log("Created temporary npm auth config outside the workspace.");
+  if (!process.env.GITHUB_ENV) {
+    console.log(`Use NPM_CONFIG_USERCONFIG=${configPath} for the current command.`);
+  }
 }
 
-main().catch((error) => {
-  console.error(error.message);
-  process.exitCode = 1;
-});
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main().catch((error) => {
+    console.error(error.message);
+    process.exitCode = 1;
+  });
+}

package/scripts/skills-install.js

@@ -1,22 +1,29 @@
 #!/usr/bin/env node
 
 import process from "node:process";
-import { installSkills } from "../src/skill-installer.js";
+import { installSkills, rollbackInstalledAssets } from "../src/skill-installer.js";
 
 function parseArgs(argv) {
-  const args = { path: null };
+  const args = { path: null, rollback: false };
   for (let index = 0; index < argv.length; index += 1) {
     const token = argv[index];
     if (token === "--path") {
       args.path = argv[index + 1];
       index += 1;
     }
+    if (token === "--rollback") args.rollback = true;
   }
   return args;
 }
 
 async function main() {
   const args = parseArgs(process.argv.slice(2));
+  if (args.rollback) {
+    console.log(
+      JSON.stringify(await rollbackInstalledAssets({ targetRoot: args.path ?? undefined })),
+    );
+    return;
+  }
   const { installed } = await installSkills({ targetRoot: args.path ?? undefined });
   for (const skill of installed) {
     console.log(`installed ${skill.name} -> ${skill.dest}`);

package/scripts/skills-manifest.js

@@ -3,31 +3,12 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
+import { parseSkillFrontmatter, validateSkillFrontmatter } from "../src/skill-frontmatter.js";
 
 const repoRoot = process.cwd();
 const skillsRoot = path.join(repoRoot, "skills");
 const manifestPath = path.join(skillsRoot, "index.json");
 
-function parseFrontmatterNameAndDescription(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---/);
-  if (!match) {
-    throw new Error("Missing SKILL.md frontmatter");
-  }
-
-  const lines = match[1].split("\n");
-  let name = "";
-  let description = "";
-  for (const line of lines) {
-    if (line.startsWith("name:")) {
-      name = line.slice("name:".length).trim();
-    }
-    if (line.startsWith("description:")) {
-      description = line.slice("description:".length).trim().replace(/^"|"$/g, "");
-    }
-  }
-  return { name, description };
-}
-
 async function main() {
   const entries = await fs.readdir(skillsRoot, { withFileTypes: true });
   const skills = [];
@@ -39,7 +20,7 @@ async function main() {
 
     const skillPath = path.join(skillsRoot, entry.name, "SKILL.md");
     const content = await fs.readFile(skillPath, "utf8");
-    const meta = parseFrontmatterNameAndDescription(content);
+    const meta = validateSkillFrontmatter(parseSkillFrontmatter(content), entry.name);
     skills.push({
       name: meta.name,
       path: `skills/${entry.name}`,

package/scripts/skills-pack.js

@@ -2,9 +2,9 @@
 
 import { spawnSync } from "node:child_process";
 import fs from "node:fs/promises";
-import os from "node:os";
 import path from "node:path";
 import process from "node:process";
+import { createTestNamespace } from "../src/test-fixtures.js";
 
 const repoRoot = process.cwd();
 const distRoot = path.join(repoRoot, "dist");
@@ -28,7 +28,7 @@ async function copyDir(src, dest) {
 async function main() {
   await fs.mkdir(distRoot, { recursive: true });
   await fs.rm(bundlePath, { force: true });
-  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "meta-architect-skills-"));
+  const tempRoot = createTestNamespace("meta-architect-skills");
   const frozenSkillsRoot = path.join(tempRoot, "skills");
   await copyDir(skillsRoot, frozenSkillsRoot);
 

package/scripts/skills-validate.js

@@ -3,6 +3,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
+import { parseSkillFrontmatter, validateSkillFrontmatter } from "../src/skill-frontmatter.js";
 
 const repoRoot = process.cwd();
 const skillsRoot = path.join(repoRoot, "skills");
@@ -12,42 +13,6 @@ function fail(message) {
   process.exitCode = 1;
 }
 
-function extractFrontmatter(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---\n?/);
-  if (!match) {
-    return null;
-  }
-
-  const yaml = match[1];
-  const result = {};
-
-  for (const rawLine of yaml.split("\n")) {
-    const line = rawLine.trim();
-    if (!line || line.startsWith("#")) {
-      continue;
-    }
-
-    const separator = line.indexOf(":");
-    if (separator === -1) {
-      continue;
-    }
-
-    const key = line.slice(0, separator).trim();
-    let value = line.slice(separator + 1).trim();
-
-    if (
-      (value.startsWith('"') && value.endsWith('"')) ||
-      (value.startsWith("'") && value.endsWith("'"))
-    ) {
-      value = value.slice(1, -1);
-    }
-
-    result[key] = value;
-  }
-
-  return result;
-}
-
 async function validateSkillDir(skillDir) {
   const skillName = path.basename(skillDir);
   const skillPath = path.join(skillDir, "SKILL.md");
@@ -58,25 +23,10 @@ async function validateSkillDir(skillDir) {
     throw new Error(`${skillName}: missing SKILL.md`);
   }
 
-  const frontmatter = extractFrontmatter(skillContent);
-  if (!frontmatter) {
-    throw new Error(`${skillName}: SKILL.md missing frontmatter`);
-  }
-
-  if (!frontmatter.name) {
-    throw new Error(`${skillName}: frontmatter missing name`);
-  }
-
-  if (frontmatter.name !== skillName) {
-    throw new Error(`${skillName}: frontmatter name must match directory name`);
-  }
-
-  if (!/^[a-z0-9-]+$/.test(frontmatter.name)) {
-    throw new Error(`${skillName}: frontmatter name must be lowercase kebab-case`);
-  }
-
-  if (!frontmatter.description || frontmatter.description.length < 10) {
-    throw new Error(`${skillName}: frontmatter description is missing or too short`);
+  try {
+    validateSkillFrontmatter(parseSkillFrontmatter(skillContent), skillName);
+  } catch (error) {
+    throw new Error(`${skillName}: ${error.message}`);
   }
 
   const agentContent = await fs.readFile(agentPath, "utf8").catch(() => null);

package/src/agents.js

@@ -0,0 +1,279 @@
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+
+const definitions = {
+  codex: {
+    id: "codex",
+    displayName: "Codex CLI",
+    skillsDir: ".agents/skills",
+    globalSkillsDir: "~/.agents/skills",
+    isUniversal: true,
+    command: "codex",
+    surface: "cli",
+    vendor: "openai",
+    probeable: true,
+  },
+  "claude-code": {
+    id: "claude-code",
+    displayName: "Claude Code",
+    skillsDir: ".claude/skills",
+    globalSkillsDir: "~/.claude/skills",
+    isUniversal: false,
+    command: "claude",
+    surface: "cli",
+    vendor: "anthropic",
+    probeable: true,
+  },
+  cursor: {
+    id: "cursor",
+    displayName: "Cursor",
+    skillsDir: ".agents/skills",
+    globalSkillsDir: "~/.agents/skills",
+    isUniversal: true,
+    command: "cursor",
+    surface: "ide",
+    vendor: "cursor",
+    probeable: true,
+  },
+  opencode: {
+    id: "opencode",
+    displayName: "OpenCode",
+    skillsDir: ".agents/skills",
+    globalSkillsDir: "~/.config/opencode/skills",
+    isUniversal: true,
+    command: "opencode",
+    surface: "cli",
+    vendor: "sst",
+    probeable: true,
+  },
+  "gemini-cli": {
+    id: "gemini-cli",
+    displayName: "Gemini CLI",
+    skillsDir: ".agents/skills",
+    globalSkillsDir: "~/.gemini/skills",
+    isUniversal: true,
+    command: "gemini",
+    surface: "cli",
+    vendor: "google",
+    probeable: true,
+  },
+  amp: {
+    id: "amp",
+    displayName: "Amp",
+    skillsDir: ".agents/skills",
+    globalSkillsDir: "~/.config/agents/skills",
+    isUniversal: true,
+    command: "amp",
+    surface: "cli",
+    vendor: "sourcegraph",
+    probeable: true,
+  },
+  goose: {
+    id: "goose",
+    displayName: "Goose",
+    skillsDir: ".goose/skills",
+    globalSkillsDir: "~/.config/goose/skills",
+    isUniversal: false,
+    command: "goose",
+    surface: "cli",
+    vendor: "block",
+    probeable: true,
+  },
+  "hermes-agent": {
+    id: "hermes-agent",
+    displayName: "Hermes Agent",
+    skillsDir: ".hermes/skills",
+    globalSkillsDir: "~/.hermes/skills",
+    isUniversal: false,
+    command: "hermes",
+    surface: "cli",
+    vendor: "nous-research",
+    probeable: true,
+  },
+  pi: {
+    id: "pi",
+    displayName: "Pi Coding Agent",
+    skillsDir: ".pi/skills",
+    globalSkillsDir: "~/.pi/agent/skills",
+    isUniversal: false,
+    command: "pi",
+    surface: "cli",
+    vendor: "pi",
+    probeable: true,
+  },
+  windsurf: {
+    id: "windsurf",
+    displayName: "Windsurf",
+    skillsDir: ".windsurf/skills",
+    globalSkillsDir: "~/.codeium/windsurf/skills",
+    isUniversal: false,
+    command: null,
+    surface: "ide",
+    vendor: "windsurf",
+    probeable: false,
+  },
+  cline: {
+    id: "cline",
+    displayName: "Cline",
+    skillsDir: ".agents/skills",
+    globalSkillsDir: "~/.agents/skills",
+    isUniversal: true,
+    command: null,
+    surface: "ide",
+    vendor: "cline",
+    probeable: false,
+  },
+  continue: {
+    id: "continue",
+    displayName: "Continue",
+    skillsDir: ".continue/skills",
+    globalSkillsDir: "~/.continue/skills",
+    isUniversal: false,
+    command: "continue",
+    surface: "ide",
+    vendor: "continue",
+    probeable: true,
+  },
+  roo: {
+    id: "roo",
+    displayName: "Roo Code",
+    skillsDir: ".roo/skills",
+    globalSkillsDir: "~/.roo/skills",
+    isUniversal: false,
+    command: null,
+    surface: "ide",
+    vendor: "roo-code",
+    probeable: false,
+  },
+  "kiro-cli": {
+    id: "kiro-cli",
+    displayName: "Kiro CLI",
+    skillsDir: ".kiro/skills",
+    globalSkillsDir: "~/.kiro/skills",
+    isUniversal: false,
+    command: "kiro",
+    surface: "ide",
+    vendor: "amazon",
+    probeable: true,
+  },
+  junie: {
+    id: "junie",
+    displayName: "Junie",
+    skillsDir: ".junie/skills",
+    globalSkillsDir: "~/.junie/skills",
+    isUniversal: false,
+    command: null,
+    surface: "ide",
+    vendor: "jetbrains",
+    probeable: false,
+  },
+  "github-copilot": {
+    id: "github-copilot",
+    displayName: "GitHub Copilot",
+    skillsDir: ".agents/skills",
+    globalSkillsDir: "~/.copilot/skills",
+    isUniversal: true,
+    command: null,
+    surface: "ide",
+    vendor: "github",
+    probeable: false,
+  },
+  antigravity: {
+    id: "antigravity",
+    displayName: "Antigravity",
+    skillsDir: ".agents/skills",
+    globalSkillsDir: "~/.gemini/antigravity/skills",
+    isUniversal: true,
+    command: null,
+    surface: "ide",
+    vendor: "google",
+    probeable: false,
+  },
+  universal: {
+    id: "universal",
+    displayName: "Universal Agent Skills",
+    skillsDir: ".agents/skills",
+    globalSkillsDir: "~/.agents/skills",
+    isUniversal: true,
+    command: null,
+    surface: "generic",
+    vendor: "universal",
+    probeable: false,
+  },
+};
+
+export const agentRegistry = Object.freeze(
+  Object.fromEntries(
+    Object.entries(definitions).map(([id, definition]) => [id, Object.freeze(definition)]),
+  ),
+);
+
+export function getAgent(type = process.env.MA_AGENT || "codex") {
+  return agentRegistry[type] ?? agentRegistry.codex;
+}
+
+export function getNonUniversalAgents() {
+  return Object.values(agentRegistry).filter((agent) => !agent.isUniversal);
+}
+
+export function isUniversalAgent(type) {
+  return getAgent(type).isUniversal;
+}
+
+export function resolveAgentCommand(type = process.env.MA_AGENT || "codex") {
+  const agent = getAgent(type);
+  if (!agent.command) return null;
+  const envKey = `MA_${agent.id.replaceAll("-", "_").toUpperCase()}_BIN`;
+  return process.env[envKey]?.trim() || agent.command;
+}
+
+export function detectInstalled(type = process.env.MA_AGENT || "codex") {
+  const agent = getAgent(type);
+  const command = resolveAgentCommand(agent.id);
+  if (!command || !agent.probeable) {
+    return {
+      ...agent,
+      installed: false,
+      command: command ?? null,
+      version: "",
+      probe: "unsupported",
+    };
+  }
+  const script = [".js", ".mjs", ".cjs"].includes(path.extname(command));
+  const result = spawnSync(
+    script ? process.execPath : command,
+    script ? [command, "--version"] : ["--version"],
+    {
+      encoding: "utf8",
+    },
+  );
+  return {
+    ...agent,
+    command,
+    installed: result.status === 0,
+    version: result.status === 0 ? result.stdout.trim() : "",
+    error: result.error?.message || result.stderr?.trim() || "",
+  };
+}
+
+export function listAgents() {
+  return Object.values(agentRegistry);
+}
+
+const slashInvocationAgents = new Set([
+  "cursor",
+  "windsurf",
+  "cline",
+  "continue",
+  "roo",
+  "kiro-cli",
+  "junie",
+  "github-copilot",
+  "antigravity",
+]);
+
+export function getAgentInvocation(type, command = "maestro") {
+  if (type === "codex") return `$${command}`;
+  if (slashInvocationAgents.has(type)) return `/${command}`;
+  return command;
+}