@jstn-sdk/ma 0.1.1 → 0.1.3

package/scripts/release-sync.js

@@ -0,0 +1,348 @@
+#!/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: "",
+  };
+
+  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;
+    }
+  }
+
+  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 }) {
+  if (process.env.RELEASE_SYNC_CHANGED_FILES) {
+    return process.env.RELEASE_SYNC_CHANGED_FILES.split("\n")
+      .map((line) => line.trim())
+      .filter(Boolean);
+  }
+
+  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 = changedFiles.filter(isWatchedPath);
+
+  if (relevantChanges.length === 0) {
+    if (args.githubOutput) {
+      writeGithubOutput(args.githubOutput, { updated: "false", version: currentVersion });
+    }
+    console.log(
+      JSON.stringify(
+        {
+          updated: 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,
+        bump: bumpKind,
+        previousVersion: currentVersion,
+        version: nextVersion,
+        changedFiles: relevantChanges,
+      },
+      null,
+      2,
+    ),
+  );
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(error.message);
+  process.exitCode = 1;
+}

package/skills/arch/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
-  display_name: "MA Architect"
-  short_description: "Architecture and stack design for MA flows"
+  display_name: "$arch"
+  short_description: "Architecture-first product and system design"
   default_prompt: "Use $arch to produce architecture, stack rationale, subsystem boundaries, tradeoffs, and a phased delivery plan."

package/skills/build/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
-  display_name: "MA Build"
-  short_description: "Gated build planning and branch/worktree prep"
+  display_name: "$build"
+  short_description: "Build-readiness decision and next implementation step"
   default_prompt: "Use $build to decide whether implementation is ready, what remains blocked, and what the next build slice should be."

package/skills/flow/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
-  display_name: "MA Flow"
-  short_description: "Business logic and state validation for MA"
+  display_name: "$flow"
+  short_description: "Logic, states, transitions, and blockers"
   default_prompt: "Use $flow to map business logic, state transitions, invariants, and blockers in the current design."

package/skills/meta-architect/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
-  display_name: "Meta-Architect"
-  short_description: "Core orchestration and gated build workflows"
+  display_name: "$meta-architect"
+  short_description: "Full Meta-Architect skill workflow"
   default_prompt: "Use $meta-architect to run the full Meta-Architect workflow inside Codex, then route through $arch, $sage, $flow, $vet, $vibe, and $build as needed."

package/skills/sage/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
-  display_name: "MA Sage"
-  short_description: "GitMCP-backed OSS evidence selection"
+  display_name: "$sage"
+  short_description: "Evidence-backed stack and OSS validation"
   default_prompt: "Use $sage to validate stack choices with official docs, upstream repos, and approved GitMCP-backed sources."

package/skills/vet/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
-  display_name: "MA Vet"
-  short_description: "Security, CVE, and risk review for MA"
+  display_name: "$vet"
+  short_description: "Security and trust-boundary review"
   default_prompt: "Use $vet to review trust boundaries, security risks, abuse cases, and safer alternatives in the current design."

package/skills/vibe/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
-  display_name: "MA Vibe"
-  short_description: "DX and UX review before Meta-Architect build"
+  display_name: "$vibe"
+  short_description: "DX and UX review before implementation"
   default_prompt: "Use $vibe to review developer and user experience risks before the build lane proceeds."

package/src/launcher.js

@@ -6,6 +6,7 @@ const nativeCommands = new Set([
   "init",
   "idea",
   "skills",
+  "sdk-path",
   "status",
   "merge",
   "release",

package/src/mcp-live-client.js

@@ -38,7 +38,7 @@ export class McpSseClient {
       capabilities: {},
       clientInfo: {
         name: "meta-architect",
-        version: "0.1.1",
+        version: "0.1.3",
       },
     });
 

package/src/skill-installer.js

@@ -3,9 +3,16 @@ import os from "node:os";
 import path from "node:path";
 import { packageRoot } from "./paths.js";
 
+function resolveCodexHome() {
+  return process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex");
+}
+
 function resolveSkillInstallRoot() {
-  const codexHome = process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex");
-  return path.join(codexHome, "skills");
+  return path.join(resolveCodexHome(), "skills");
+}
+
+function resolveSupportBundleRoot() {
+  return path.join(resolveCodexHome(), "meta-architect-sdk");
 }
 
 async function copyDir(src, dest) {
@@ -26,6 +33,10 @@ export function getSkillInstallRoot() {
   return resolveSkillInstallRoot();
 }
 
+export function getSupportBundleRoot() {
+  return resolveSupportBundleRoot();
+}
+
 export async function loadSkillManifest() {
   const manifestPath = path.join(packageRoot, "skills", "index.json");
   const manifest = JSON.parse(await fs.readFile(manifestPath, "utf8"));
@@ -47,3 +58,141 @@ export async function installSkills({ targetRoot = getSkillInstallRoot() } = {})
 
   return { targetRoot, installed };
 }
+
+async function copyPath(src, dest) {
+  const stat = await fs.stat(src);
+  if (stat.isDirectory()) {
+    await fs.rm(dest, { recursive: true, force: true });
+    await copyDir(src, dest);
+    return "directory";
+  }
+
+  await fs.mkdir(path.dirname(dest), { recursive: true });
+  await fs.copyFile(src, dest);
+  return "file";
+}
+
+export async function installSupportBundle({ targetRoot = getSupportBundleRoot() } = {}) {
+  const assets = [
+    {
+      name: "mcp",
+      src: path.join(packageRoot, "mcp"),
+      dest: path.join(targetRoot, "mcp"),
+    },
+    {
+      name: "sprint",
+      src: path.join(packageRoot, "sprint"),
+      dest: path.join(targetRoot, "sprint"),
+    },
+    {
+      name: "prompts",
+      src: path.join(packageRoot, ".codex", "prompts"),
+      dest: path.join(targetRoot, "prompts"),
+    },
+    {
+      name: "scripts",
+      src: path.join(packageRoot, "scripts"),
+      dest: path.join(targetRoot, "scripts"),
+    },
+    {
+      name: "plugin",
+      src: path.join(packageRoot, "plugins", "meta-architect"),
+      dest: path.join(targetRoot, "plugins", "meta-architect"),
+    },
+    {
+      name: "templates",
+      src: path.join(packageRoot, "templates"),
+      dest: path.join(targetRoot, "templates"),
+    },
+    {
+      name: "docs-readme",
+      src: path.join(packageRoot, "docs", "README.md"),
+      dest: path.join(targetRoot, "docs", "README.md"),
+    },
+  ];
+
+  await fs.mkdir(targetRoot, { recursive: true });
+  const installed = [];
+  for (const asset of assets) {
+    await copyPath(asset.src, asset.dest);
+    installed.push({ name: asset.name, dest: asset.dest });
+  }
+
+  const pkg = JSON.parse(await fs.readFile(path.join(packageRoot, "package.json"), "utf8"));
+  const manifest = {
+    packageName: pkg.name,
+    packageVersion: pkg.version,
+    installedAt: new Date().toISOString(),
+    root: targetRoot,
+    assets: installed,
+  };
+  await fs.writeFile(
+    path.join(targetRoot, "asset-manifest.json"),
+    `${JSON.stringify(manifest, null, 2)}\n`,
+  );
+
+  return { targetRoot, installed };
+}
+
+export async function areSkillsInstalled({ targetRoot = getSkillInstallRoot() } = {}) {
+  const skills = await loadSkillManifest();
+
+  for (const skill of skills) {
+    const skillDir = path.join(targetRoot, path.basename(skill.path));
+    try {
+      await fs.access(path.join(skillDir, "SKILL.md"));
+    } catch {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export async function isSupportBundleInstalled({ targetRoot = getSupportBundleRoot() } = {}) {
+  const requiredFiles = [
+    path.join(targetRoot, "asset-manifest.json"),
+    path.join(targetRoot, "mcp", "servers.json"),
+    path.join(targetRoot, "sprint", "07-release.md"),
+    path.join(targetRoot, "prompts", "onboarding.md"),
+    path.join(targetRoot, "scripts", "skills-install.js"),
+    path.join(targetRoot, "plugins", "meta-architect", ".codex-plugin", "plugin.json"),
+    path.join(targetRoot, "templates", "AGENTS.md"),
+  ];
+
+  for (const file of requiredFiles) {
+    try {
+      await fs.access(file);
+    } catch {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export async function ensureSkillsInstalled({ targetRoot = getSkillInstallRoot() } = {}) {
+  if (process.env.MA_SKIP_AUTO_INSTALL === "1") {
+    return { targetRoot, installed: [], skipped: true };
+  }
+
+  if (await areSkillsInstalled({ targetRoot })) {
+    return { targetRoot, installed: [], skipped: false };
+  }
+
+  const result = await installSkills({ targetRoot });
+  return { ...result, skipped: false };
+}
+
+export async function ensureSupportBundleInstalled({ targetRoot = getSupportBundleRoot() } = {}) {
+  if (process.env.MA_SKIP_AUTO_INSTALL === "1") {
+    return { targetRoot, installed: [], skipped: true };
+  }
+
+  if (await isSupportBundleInstalled({ targetRoot })) {
+    return { targetRoot, installed: [], skipped: false };
+  }
+
+  const result = await installSupportBundle({ targetRoot });
+  return { ...result, skipped: false };
+}

package/src/skills.js

@@ -344,8 +344,8 @@ export async function runInit() {
       path.join(getRepoRoot(), "docs", "release-spec.md"),
     ],
     [
-      path.join(packageRoot, "docs", "qa", "release-readiness-0.1.1.md"),
-      path.join(getRepoRoot(), "docs", "qa", "release-readiness-0.1.1.md"),
+      path.join(packageRoot, "docs", "qa", "release-readiness-0.1.3.md"),
+      path.join(getRepoRoot(), "docs", "qa", "release-readiness-0.1.3.md"),
     ],
   ];