@jstn-sdk/ma 0.1.5 → 0.1.7

package/scripts/release-metadata.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import process from "node:process";
+
+function loadPackageJson() {
+  return JSON.parse(fs.readFileSync("package.json", "utf8"));
+}
+
+function parseVersion(version) {
+  const match = version.match(
+    /^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(?:-(?<prerelease>[0-9A-Za-z.-]+))?$/,
+  );
+  if (!match?.groups) {
+    throw new Error(`Invalid package.json version: ${version}`);
+  }
+  return match.groups;
+}
+
+function computeMetadata(version) {
+  const parsed = parseVersion(version);
+  const prerelease = parsed.prerelease ?? "";
+  const prereleaseIdentifiers = prerelease ? prerelease.split(".") : [];
+  const isPrerelease = prereleaseIdentifiers.length > 0;
+  const distTag = isPrerelease ? prereleaseIdentifiers[0] : "latest";
+
+  return {
+    version,
+    gitTag: `v${version}`,
+    isPrerelease,
+    distTag,
+    prerelease,
+  };
+}
+
+function parseArgs(argv) {
+  const args = {
+    field: "",
+    githubOutput: "",
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === "--field") {
+      args.field = argv[index + 1] ?? "";
+      index += 1;
+      continue;
+    }
+    if (token === "--github-output") {
+      args.githubOutput = argv[index + 1] ?? "";
+      index += 1;
+    }
+  }
+
+  return args;
+}
+
+function writeGithubOutput(outputPath, metadata) {
+  const lines = [
+    `version=${metadata.version}`,
+    `git_tag=${metadata.gitTag}`,
+    `dist_tag=${metadata.distTag}`,
+    `is_prerelease=${metadata.isPrerelease}`,
+  ];
+  fs.appendFileSync(outputPath, `${lines.join("\n")}\n`);
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const pkg = loadPackageJson();
+  const metadata = computeMetadata(pkg.version);
+
+  if (args.githubOutput) {
+    writeGithubOutput(args.githubOutput, metadata);
+  }
+
+  if (args.field) {
+    const value = metadata[args.field];
+    if (value === undefined) {
+      throw new Error(`Unknown metadata field: ${args.field}`);
+    }
+    console.log(value);
+    return;
+  }
+
+  console.log(JSON.stringify(metadata, null, 2));
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(error.message);
+  process.exitCode = 1;
+}

package/scripts/release-sync.js

@@ -0,0 +1,359 @@
+#!/usr/bin/env node
+
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+
+const WATCHED_PREFIXES = [
+  "bin/",
+  "docs/",
+  "example/",
+  "mcp/",
+  "missions/",
+  "plugins/",
+  "prompts/",
+  ".codex/prompts/",
+  "sprint/",
+  "templates/",
+  "src/",
+  "skills/",
+];
+
+const WATCHED_FILES = new Set([
+  "README.md",
+  "RELEASE.md",
+  "CHANGELOG.md",
+  "package.json",
+  "package-lock.json",
+]);
+
+function parseArgs(argv) {
+  const args = {
+    bump: "",
+    fromRef: "",
+    toRef: "",
+    githubOutput: "",
+    force: false,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === "--bump") {
+      args.bump = argv[index + 1] ?? "";
+      index += 1;
+      continue;
+    }
+    if (token === "--from-ref") {
+      args.fromRef = argv[index + 1] ?? "";
+      index += 1;
+      continue;
+    }
+    if (token === "--to-ref") {
+      args.toRef = argv[index + 1] ?? "";
+      index += 1;
+      continue;
+    }
+    if (token === "--github-output") {
+      args.githubOutput = argv[index + 1] ?? "";
+      index += 1;
+      continue;
+    }
+    if (token === "--force") {
+      args.force = true;
+    }
+  }
+
+  return args;
+}
+
+function readJson(file) {
+  return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+
+function writeJson(file, value) {
+  fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function readText(file) {
+  return fs.readFileSync(file, "utf8");
+}
+
+function writeText(file, content) {
+  fs.writeFileSync(file, content);
+}
+
+function replaceRequired(text, search, replacement, label) {
+  if (!text.includes(search)) {
+    throw new Error(`Expected to find ${label}: ${search}`);
+  }
+  return text.replaceAll(search, replacement);
+}
+
+function parseVersion(version) {
+  const match = version.match(/^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)$/);
+  if (!match?.groups) {
+    throw new Error(`Unsupported version for release-sync: ${version}`);
+  }
+  return {
+    major: Number(match.groups.major),
+    minor: Number(match.groups.minor),
+    patch: Number(match.groups.patch),
+  };
+}
+
+function bumpVersion(version, bumpKind) {
+  const parsed = parseVersion(version);
+  if (bumpKind === "major") {
+    return `${parsed.major + 1}.0.0`;
+  }
+  if (bumpKind === "minor") {
+    return `${parsed.major}.${parsed.minor + 1}.0`;
+  }
+  return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}`;
+}
+
+function git(args) {
+  return execFileSync("git", args, { encoding: "utf8" }).trim();
+}
+
+function getChangedFiles({ fromRef, toRef, force }) {
+  if (process.env.RELEASE_SYNC_CHANGED_FILES) {
+    return process.env.RELEASE_SYNC_CHANGED_FILES.split("\n")
+      .map((line) => line.trim())
+      .filter(Boolean);
+  }
+
+  if (force) {
+    return [];
+  }
+
+  if (fromRef && toRef && !/^0+$/.test(fromRef)) {
+    return git(["diff", "--name-only", fromRef, toRef])
+      .split("\n")
+      .map((line) => line.trim())
+      .filter(Boolean);
+  }
+
+  return git(["status", "--porcelain"])
+    .split("\n")
+    .map((line) => line.slice(3).trim())
+    .filter(Boolean);
+}
+
+function isWatchedPath(file) {
+  return WATCHED_FILES.has(file) || WATCHED_PREFIXES.some((prefix) => file.startsWith(prefix));
+}
+
+function prependChangelog(version) {
+  const changelogPath = "CHANGELOG.md";
+  const changelog = readText(changelogPath);
+  if (changelog.includes(`## v${version}`)) {
+    return;
+  }
+
+  const next = changelog.replace(
+    "# Changelog\n\n",
+    `# Changelog\n\n## v${version}\n\n- Release line prepared automatically for v${version}.\n\n`,
+  );
+  writeText(changelogPath, next);
+}
+
+function updateCurrentSurfaceFile(file, oldVersion, nextVersion) {
+  const oldTag = `v${oldVersion}`;
+  const nextTag = `v${nextVersion}`;
+  const oldQa = `release-readiness-${oldVersion}.md`;
+  const nextQa = `release-readiness-${nextVersion}.md`;
+  let content = readText(file);
+  if (content.includes(oldTag)) {
+    content = content.replaceAll(oldTag, nextTag);
+  }
+  if (content.includes(oldVersion)) {
+    content = content.replaceAll(oldVersion, nextVersion);
+  }
+  content = content.replaceAll(oldQa, nextQa);
+  writeText(file, content);
+}
+
+function syncPackageVersion(nextVersion) {
+  const pkg = readJson("package.json");
+  const lock = readJson("package-lock.json");
+  pkg.version = nextVersion;
+  lock.version = nextVersion;
+  if (lock.packages?.[""]) {
+    lock.packages[""].version = nextVersion;
+  }
+  writeJson("package.json", pkg);
+  writeJson("package-lock.json", lock);
+}
+
+function syncPluginVersions(nextVersion) {
+  for (const file of [
+    path.join("plugins", "meta-architect", ".app.json"),
+    path.join("plugins", "meta-architect", ".mcp.json"),
+    path.join("plugins", "meta-architect", ".codex-plugin", "plugin.json"),
+  ]) {
+    const value = readJson(file);
+    value.version = nextVersion;
+    writeJson(file, value);
+  }
+}
+
+function syncCurrentReleaseFiles(oldVersion, nextVersion) {
+  for (const file of [
+    "README.md",
+    "RELEASE.md",
+    path.join("docs", "README.md"),
+    path.join("docs", "getting-started.md"),
+    path.join("docs", "release-spec.md"),
+    path.join("plugins", "meta-architect", "README.md"),
+  ]) {
+    updateCurrentSurfaceFile(file, oldVersion, nextVersion);
+  }
+
+  const oldQa = path.join("docs", "qa", `release-readiness-${oldVersion}.md`);
+  const nextQa = path.join("docs", "qa", `release-readiness-${nextVersion}.md`);
+  fs.renameSync(oldQa, nextQa);
+  updateCurrentSurfaceFile(nextQa, oldVersion, nextVersion);
+}
+
+function syncSupportingCode(oldVersion, nextVersion) {
+  const replacements = [
+    {
+      file: path.join("src", "skills.js"),
+      search: `release-readiness-${oldVersion}.md`,
+      replacement: `release-readiness-${nextVersion}.md`,
+      label: "skills QA path",
+    },
+    {
+      file: path.join("src", "mcp-live-client.js"),
+      search: `version: "${oldVersion}"`,
+      replacement: `version: "${nextVersion}"`,
+      label: "mcp live client version",
+    },
+    {
+      file: path.join("test", "package-install-smoke.test.js"),
+      search: `jstn-sdk-ma-${oldVersion}.tgz`,
+      replacement: `jstn-sdk-ma-${nextVersion}.tgz`,
+      label: "tarball filename",
+    },
+    {
+      file: path.join("test", "policy.test.js"),
+      search: `release/${oldVersion}`,
+      replacement: `release/${nextVersion}`,
+      label: "release branch example",
+    },
+  ];
+
+  for (const entry of replacements) {
+    const content = readText(entry.file);
+    writeText(entry.file, replaceRequired(content, entry.search, entry.replacement, entry.label));
+  }
+}
+
+function rewriteReleaseState(nextVersion, previousVersion) {
+  const releasePath = "RELEASE.md";
+  const qaPath = path.join("docs", "qa", `release-readiness-${nextVersion}.md`);
+
+  let release = readText(releasePath);
+  release = release.replace(
+    /- npm package: `@jstn-sdk\/ma@[0-9]+\.[0-9]+\.[0-9]+`/,
+    `- npm package: \`@jstn-sdk/ma@${nextVersion}\``,
+  );
+  release = release.replace(
+    /- publishability note: .+/,
+    `- publishability note: \`${previousVersion}\` is already published, so \`${nextVersion}\` is the next publishable package line`,
+  );
+  release = release.replace(
+    /- GitHub release: .+/,
+    `- GitHub release: pending publish for \`v${nextVersion}\``,
+  );
+  release = release.replace(
+    /- npm publication has not been run yet for `@jstn-sdk\/ma@[0-9]+\.[0-9]+\.[0-9]+`/,
+    `- npm publication has not been run yet for \`@jstn-sdk/ma@${nextVersion}\``,
+  );
+  writeText(releasePath, release);
+
+  let qa = readText(qaPath);
+  qa = qa.replace(
+    /- npm package: `@jstn-sdk\/ma@[0-9]+\.[0-9]+\.[0-9]+`/,
+    `- npm package: \`@jstn-sdk/ma@${nextVersion}\``,
+  );
+  qa = qa.replace(
+    /- publishability note: .+/,
+    `- publishability note: \`${previousVersion}\` is already published, so \`${nextVersion}\` is the next publishable package line`,
+  );
+  qa = qa.replace(
+    /- GitHub release: .+/,
+    `- GitHub release: pending publish for \`v${nextVersion}\``,
+  );
+  writeText(qaPath, qa);
+}
+
+function writeGithubOutput(outputPath, { updated, version }) {
+  const lines = [`updated=${updated}`, `version=${version}`];
+  fs.appendFileSync(outputPath, `${lines.join("\n")}\n`);
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const pkg = readJson("package.json");
+  const currentVersion = pkg.version;
+  const changedFiles = getChangedFiles(args);
+  const relevantChanges = args.force ? ["<forced>"] : changedFiles.filter(isWatchedPath);
+
+  if (relevantChanges.length === 0 && !args.force) {
+    if (args.githubOutput) {
+      writeGithubOutput(args.githubOutput, { updated: "false", version: currentVersion });
+    }
+    console.log(
+      JSON.stringify(
+        {
+          updated: false,
+          forced: false,
+          version: currentVersion,
+          changedFiles,
+        },
+        null,
+        2,
+      ),
+    );
+    return;
+  }
+
+  const bumpKind = args.bump || "patch";
+  const nextVersion = bumpVersion(currentVersion, bumpKind);
+
+  syncPackageVersion(nextVersion);
+  syncPluginVersions(nextVersion);
+  prependChangelog(nextVersion);
+  syncCurrentReleaseFiles(currentVersion, nextVersion);
+  syncSupportingCode(currentVersion, nextVersion);
+  rewriteReleaseState(nextVersion, currentVersion);
+
+  if (args.githubOutput) {
+    writeGithubOutput(args.githubOutput, { updated: "true", version: nextVersion });
+  }
+
+  console.log(
+    JSON.stringify(
+      {
+        updated: true,
+        forced: args.force,
+        bump: bumpKind,
+        previousVersion: currentVersion,
+        version: nextVersion,
+        changedFiles: relevantChanges,
+      },
+      null,
+      2,
+    ),
+  );
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(error.message);
+  process.exitCode = 1;
+}

package/scripts/release-verify.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+
+const CANONICAL_PACKAGE = "@jstn-sdk/ma";
+const CANONICAL_INSTALL = "npm i -g @openai/codex@latest @jstn-sdk/ma@latest";
+const CANONICAL_LAUNCH = "ma --madmax --high";
+const UNINSTALL_MA = "npm uninstall -g @jstn-sdk/ma";
+const UNINSTALL_BOTH = "npm uninstall -g @jstn-sdk/ma @openai/codex";
+
+function readJson(file) {
+  return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+
+function readText(file) {
+  return fs.readFileSync(file, "utf8");
+}
+
+function fail(message) {
+  throw new Error(message);
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    fail(message);
+  }
+}
+
+function parseVersion(version) {
+  const match = version.match(
+    /^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(?:-(?<prerelease>[0-9A-Za-z.-]+))?$/,
+  );
+  if (!match?.groups) {
+    fail(`Invalid package version: ${version}`);
+  }
+  return match.groups;
+}
+
+function verifyInstallBlock(file) {
+  const content = readText(file);
+  if (!content.includes(CANONICAL_INSTALL)) {
+    return;
+  }
+
+  assert(content.includes(CANONICAL_LAUNCH), `${file}: missing canonical launch command`);
+  assert(content.includes(UNINSTALL_MA), `${file}: missing uninstall Meta-Architect command`);
+  assert(
+    content.includes(UNINSTALL_BOTH),
+    `${file}: missing uninstall Meta-Architect + Codex command`,
+  );
+}
+
+function main() {
+  const pkg = readJson("package.json");
+  const lock = readJson("package-lock.json");
+  const version = pkg.version;
+  const gitTag = `v${version}`;
+  const parsed = parseVersion(version);
+  const isPrerelease = Boolean(parsed.prerelease);
+
+  assert(pkg.name === CANONICAL_PACKAGE, "package.json: wrong package name");
+  assert(lock.name === CANONICAL_PACKAGE, "package-lock.json: wrong package name");
+  assert(lock.version === version, "package-lock.json: version drift from package.json");
+  assert(lock.packages?.[""]?.version === version, "package-lock.json: root package version drift");
+  assert(
+    pkg.publishConfig?.access === "public",
+    "package.json: publishConfig.access must be public",
+  );
+
+  const changelog = readText("CHANGELOG.md");
+  assert(changelog.includes(`## ${gitTag}`), "CHANGELOG.md: missing current version heading");
+
+  const release = readText("RELEASE.md");
+  assert(release.includes(`# Meta-Architect ${gitTag}`), "RELEASE.md: wrong title version");
+
+  const releaseSpec = readText(path.join("docs", "release-spec.md"));
+  assert(
+    releaseSpec.includes(`# ${gitTag} Requirements & Rules`),
+    "docs/release-spec.md: wrong title version",
+  );
+  assert(
+    releaseSpec.includes(`package.json\` version \`${version}\``) ||
+      releaseSpec.includes(`package.json\` version \`${version}`),
+    "docs/release-spec.md: missing package version reference",
+  );
+  assert(
+    releaseSpec.includes(`git tag \`${gitTag}\``),
+    "docs/release-spec.md: missing git tag reference",
+  );
+
+  const qaPath = path.join("docs", "qa", `release-readiness-${version}.md`);
+  assert(fs.existsSync(qaPath), `Missing QA release-readiness file: ${qaPath}`);
+  const qa = readText(qaPath);
+  assert(qa.includes(`# Release Readiness ${version}`), `${qaPath}: wrong title version`);
+
+  const pluginApp = readJson(path.join("plugins", "meta-architect", ".app.json"));
+  const pluginMcp = readJson(path.join("plugins", "meta-architect", ".mcp.json"));
+  const pluginManifest = readJson(
+    path.join("plugins", "meta-architect", ".codex-plugin", "plugin.json"),
+  );
+  assert(pluginApp.version === version, "plugins/meta-architect/.app.json: version drift");
+  assert(pluginMcp.version === version, "plugins/meta-architect/.mcp.json: version drift");
+  assert(
+    pluginManifest.version === version,
+    "plugins/meta-architect/.codex-plugin/plugin.json: version drift",
+  );
+
+  for (const file of [
+    "README.md",
+    path.join("docs", "getting-started.md"),
+    path.join("docs", "onboarding.md"),
+    path.join("docs", "skills.md"),
+    path.join("plugins", "meta-architect", "README.md"),
+  ]) {
+    verifyInstallBlock(file);
+  }
+
+  const envTag =
+    process.env.RELEASE_TAG || process.env.GITHUB_REF_NAME || process.env.GIT_TAG || "";
+  if (envTag.startsWith("v")) {
+    assert(envTag === gitTag, `Release tag mismatch: expected ${gitTag}, got ${envTag}`);
+  }
+
+  if (isPrerelease) {
+    const prereleaseTag = parsed.prerelease.split(".")[0];
+    assert(
+      prereleaseTag && prereleaseTag !== "latest",
+      `Prerelease version ${version} must resolve to an explicit non-latest dist-tag`,
+    );
+  }
+
+  console.log(
+    JSON.stringify(
+      {
+        name: pkg.name,
+        version,
+        gitTag,
+        isPrerelease,
+      },
+      null,
+      2,
+    ),
+  );
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(error.message);
+  process.exitCode = 1;
+}

package/scripts/setup-npmrc.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+
+function normalizeRegistry(registryUrl) {
+  return registryUrl.endsWith("/") ? registryUrl : `${registryUrl}/`;
+}
+
+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.");
+    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"}.`,
+  );
+}
+
+main().catch((error) => {
+  console.error(error.message);
+  process.exitCode = 1;
+});

package/scripts/skills-install.js

@@ -1,12 +1,7 @@
 #!/usr/bin/env node
 
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
 import process from "node:process";
-
-const repoRoot = process.cwd();
-const skillsRoot = path.join(repoRoot, "skills");
+import { installSkills } from "../src/skill-installer.js";
 
 function parseArgs(argv) {
   const args = { path: null };
@@ -20,38 +15,11 @@ function parseArgs(argv) {
   return args;
 }
 
-async function copyDir(src, dest) {
-  await fs.mkdir(dest, { recursive: true });
-  const entries = await fs.readdir(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      await copyDir(srcPath, destPath);
-    } else {
-      await fs.copyFile(srcPath, destPath);
-    }
-  }
-}
-
 async function main() {
   const args = parseArgs(process.argv.slice(2));
-  const targetRoot =
-    args.path ?? path.join(process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex"), "skills");
-
-  await fs.mkdir(targetRoot, { recursive: true });
-  const skillEntries = await fs.readdir(skillsRoot, { withFileTypes: true });
-
-  for (const entry of skillEntries) {
-    if (!entry.isDirectory()) {
-      continue;
-    }
-
-    const src = path.join(skillsRoot, entry.name);
-    const dest = path.join(targetRoot, entry.name);
-    await fs.rm(dest, { recursive: true, force: true });
-    await copyDir(src, dest);
-    console.log(`installed ${entry.name} -> ${dest}`);
+  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

@@ -50,7 +50,7 @@ async function main() {
   skills.sort((left, right) => left.name.localeCompare(right.name));
   await fs.writeFile(
     manifestPath,
-    `${JSON.stringify({ schemaVersion: "1.0.0", skills }, null, 2)}\n`,
+    `${JSON.stringify({ schemaVersion: "0.1.0", skills }, null, 2)}\n`,
   );
   console.log(manifestPath);
 }