@programinglive/dev-workflow-mcp-server 1.5.0 → 1.5.2

package/tests/hello-world.test.js

@@ -1,13 +1,13 @@
-import { test } from 'node:test';
-import assert from 'node:assert';
-import { execSync } from 'node:child_process';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-test('hello world script runs successfully', (t) => {
-    const scriptPath = path.join(__dirname, '../scripts/hello-world.js');
-    const output = execSync(`node ${scriptPath}`).toString();
-    assert.match(output, /Hello from Antigravity!/);
-});
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { execSync } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+test('hello world script runs successfully', (t) => {
+    const scriptPath = path.join(__dirname, '../scripts/hello-world.js');
+    const output = execSync(`node ${scriptPath}`).toString();
+    assert.match(output, /Hello from Antigravity!/);
+});

package/tests/mcpRegistry.test.js

@@ -0,0 +1,65 @@
+import { test } from "node:test";
+import assert from "node:assert";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+
+const projectRoot = process.cwd();
+
+async function readJson(relativePath) {
+  const fullPath = path.join(projectRoot, relativePath);
+  const content = await readFile(fullPath, "utf-8");
+  return JSON.parse(content);
+}
+
+test("package.json includes mcpName for MCP registry", async () => {
+  const pkg = await readJson("package.json");
+
+  assert.strictEqual(
+    pkg.mcpName,
+    "io.github.programinglive/dev-workflow-mcp-server",
+    "package.json should declare mcpName matching the MCP server namespace",
+  );
+});
+
+test("server.json is configured for npm package deployment", async () => {
+  const server = await readJson("server.json");
+
+  assert.strictEqual(
+    server.name,
+    "io.github.programinglive/dev-workflow-mcp-server",
+    "server.json name should match the MCP server namespace",
+  );
+  assert.ok(Array.isArray(server.packages) && server.packages.length > 0,
+    "server.json should declare at least one package entry",
+  );
+
+  const npmPkg = server.packages[0];
+
+  assert.strictEqual(
+    npmPkg.registryType,
+    "npm",
+    "First server.json package entry should use npm registryType",
+  );
+
+  assert.strictEqual(
+    npmPkg.registryBaseUrl,
+    "https://registry.npmjs.org",
+    "server.json npm registryBaseUrl should point at the public npm registry",
+  );
+
+  assert.strictEqual(
+    npmPkg.identifier,
+    "@programinglive/dev-workflow-mcp-server",
+    "server.json npm identifier should match the published npm package name",
+  );
+
+  assert.ok(
+    typeof npmPkg.version === "string" && npmPkg.version.length > 0,
+    "server.json npm package version should be a non-empty string",
+  );
+
+  assert.ok(
+    npmPkg.transport && npmPkg.transport.type === "stdio",
+    "server.json npm package transport should be stdio",
+  );
+});

package/tests/release-wrapper.test.js

@@ -1,105 +1,107 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtemp, rm, writeFile, readFile, mkdir } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { spawn } from "node:child_process";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const releaseWrapperUrl = new URL("../release-wrapper.js", import.meta.url);
-const RELEASE_WRAPPER = fileURLToPath(releaseWrapperUrl);
-const PROJECT_ROOT = path.dirname(RELEASE_WRAPPER);
-
-async function runWrapper({ state, args = ["patch"], env = {} }) {
-  const dir = await mkdtemp(path.join(tmpdir(), "release-wrapper-test-"));
-  const stateDir = path.join(dir, ".state");
-  const statePath = path.join(stateDir, "workflow-state.json");
-  await mkdir(stateDir, { recursive: true });
-  await writeFile(statePath, JSON.stringify(state, null, 2));
-
-  const childEnv = {
-    ...process.env,
-    INIT_CWD: dir,
-    DEV_WORKFLOW_SKIP_RELEASE: "1",
-    DEV_WORKFLOW_FORCE_RELEASE: undefined,
-    ...env,
-  };
-
-  const nodeBinary = process.platform === "win32" ? "node" : process.execPath || "node";
-  const spawnShell = process.platform === "win32";
-
-  return await new Promise((resolve) => {
-    const child = spawn(
-      nodeBinary,
-      [RELEASE_WRAPPER, ...args],
-      {
-        cwd: PROJECT_ROOT,
-        env: childEnv,
-        stdio: ["ignore", "pipe", "pipe"],
-        shell: spawnShell,
-      }
-    );
-
-    let stdout = "";
-    let stderr = "";
-
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk;
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk;
-    });
-
-    child.on("close", async (code) => {
-      let updatedState = null;
-      try {
-        const rawState = await readFile(statePath, "utf8");
-        updatedState = JSON.parse(rawState);
-      } catch {
-        // ignore
-      }
-
-      await rm(dir, { recursive: true, force: true });
-      resolve({ code, stdout, stderr, updatedState });
-    });
-  });
-}
-
-test("release-wrapper blocks when workflow phase is not release", async () => {
-  const result = await runWrapper({
-    state: {
-      currentPhase: "commit",
-      readyCheckCompleted: true,
-      commitAndPushCompleted: true,
-      released: false,
-    },
-  });
-
-  assert.equal(result.code, 1);
-  assert.ok(result.stderr.includes("Release guard blocked the release"));
-  assert.ok(result.stderr.includes("Current workflow phase"));
-  assert.equal(result.updatedState.released, false);
-});
-
-test("release-wrapper marks release after validation passes", async () => {
-  const result = await runWrapper({
-    state: {
-      currentPhase: "release",
-      readyCheckCompleted: true,
-      commitAndPushCompleted: true,
-      released: false,
-      releaseCommand: "",
-    },
-  });
-
-  assert.equal(result.code, 0);
-  assert.ok(result.stdout.includes("Release recorded"));
-  assert.equal(result.updatedState.released, true);
-  assert.equal(result.updatedState.currentPhase, "ready_to_complete");
-  assert.equal(
-    result.updatedState.releaseCommand,
-    "node node_modules/@programinglive/commiter/scripts/release.js patch"
-  );
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, rm, writeFile, readFile, mkdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const releaseWrapperUrl = new URL("../release-wrapper.js", import.meta.url);
+const RELEASE_WRAPPER = fileURLToPath(releaseWrapperUrl);
+const PROJECT_ROOT = path.dirname(RELEASE_WRAPPER);
+
+async function runWrapper({ state, args = ["patch"], env = {} }) {
+  const dir = await mkdtemp(path.join(tmpdir(), "release-wrapper-test-"));
+  const stateDir = path.join(dir, ".state");
+  const statePath = path.join(stateDir, "workflow-state.json");
+  await mkdir(stateDir, { recursive: true });
+  await writeFile(statePath, JSON.stringify(state, null, 2));
+  // Create package.json so resolveStateFile recognizes this as a project root
+  await writeFile(path.join(dir, "package.json"), JSON.stringify({ name: "test-project" }));
+
+  const childEnv = {
+    ...process.env,
+    INIT_CWD: dir,
+    DEV_WORKFLOW_SKIP_RELEASE: "1",
+    DEV_WORKFLOW_FORCE_RELEASE: undefined,
+    ...env,
+  };
+
+  const nodeBinary = process.platform === "win32" ? "node" : process.execPath || "node";
+  const spawnShell = process.platform === "win32";
+
+  return await new Promise((resolve) => {
+    const child = spawn(
+      nodeBinary,
+      [RELEASE_WRAPPER, ...args],
+      {
+        cwd: PROJECT_ROOT,
+        env: childEnv,
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: spawnShell,
+      }
+    );
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+
+    child.on("close", async (code) => {
+      let updatedState = null;
+      try {
+        const rawState = await readFile(statePath, "utf8");
+        updatedState = JSON.parse(rawState);
+      } catch {
+        // ignore
+      }
+
+      await rm(dir, { recursive: true, force: true });
+      resolve({ code, stdout, stderr, updatedState });
+    });
+  });
+}
+
+test("release-wrapper blocks when workflow phase is not release", async () => {
+  const result = await runWrapper({
+    state: {
+      currentPhase: "commit",
+      readyCheckCompleted: true,
+      commitAndPushCompleted: true,
+      released: false,
+    },
+  });
+
+  assert.equal(result.code, 1);
+  assert.ok(result.stderr.includes("Release guard blocked the release"));
+  assert.ok(result.stderr.includes("Current workflow phase"));
+  assert.equal(result.updatedState.released, false);
+});
+
+test("release-wrapper marks release after validation passes", async () => {
+  const result = await runWrapper({
+    state: {
+      currentPhase: "release",
+      readyCheckCompleted: true,
+      commitAndPushCompleted: true,
+      released: false,
+      releaseCommand: "",
+    },
+  });
+
+  assert.equal(result.code, 0);
+  assert.ok(result.stdout.includes("Release recorded"));
+  assert.equal(result.updatedState.released, true);
+  assert.equal(result.updatedState.currentPhase, "ready_to_complete");
+  assert.equal(
+    result.updatedState.releaseCommand,
+    "node node_modules/@programinglive/commiter/scripts/release.js patch"
+  );
+});