@programinglive/dev-workflow-mcp-server 1.8.1 → 1.10.0

package/tests/hello-world.test.js

@@ -1,13 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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/patch-release.test.js

@@ -1,7 +0,0 @@
-import { test } from 'node:test'
-import { strict as assert } from 'node:assert'
-
-test('patch release preparation', () => {
-  // Verify we can prepare a patch release
-  assert.ok(true, 'Patch release 1.5.3 preparation completed')
-})

package/tests/release-wrapper.test.js

@@ -1,107 +0,0 @@
-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"
-  );
-});

package/tests/startup-resilience.test.js

@@ -1,73 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert';
-import { spawn } from 'node:child_process';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const ROOT = path.join(__dirname, '..');
-
-test('Server startup performance and resilience', async (t) => {
-    await t.test('Server starts in under 2 seconds (Studio timeout safety)', async () => {
-        const start = Date.now();
-        const server = spawn('node', [path.join(ROOT, 'index.js')], {
-            env: { ...process.env, DEV_WORKFLOW_DB_TYPE: 'sqlite' },
-            stdio: ['pipe', 'pipe', 'pipe']
-        });
-
-        return new Promise((resolve, reject) => {
-            let output = '';
-            const timeout = setTimeout(() => {
-                server.kill();
-                reject(new Error('Server timed out starting'));
-            }, 5000);
-
-            server.stderr.on('data', (data) => {
-                output += data.toString();
-                if (output.includes('running on stdio')) {
-                    const duration = Date.now() - start;
-                    console.log(`Verified startup duration: ${duration}ms`);
-                    assert.ok(duration < 2000, `Startup should be fast (took ${duration}ms)`);
-                    clearTimeout(timeout);
-                    server.kill();
-                    resolve();
-                }
-            });
-
-            server.on('error', (err) => {
-                clearTimeout(timeout);
-                reject(err);
-            });
-        });
-    });
-
-    await t.test('Resilience: Server starts even with unreachable database', async () => {
-        const server = spawn('node', [path.join(ROOT, 'index.js')], {
-            env: {
-                ...process.env,
-                DEV_WORKFLOW_DB_TYPE: 'postgres',
-                DEV_WORKFLOW_DB_URL: 'postgres://user:pass@1.2.3.4:5432/invalid'
-            },
-            stdio: ['pipe', 'pipe', 'pipe']
-        });
-
-        return new Promise((resolve, reject) => {
-            let output = '';
-            const timeout = setTimeout(() => {
-                server.kill();
-                reject(new Error('Server hung on unreachable DB'));
-            }, 15000); // Allow time for the 5s DB timeout + startup
-
-            server.stderr.on('data', (data) => {
-                output += data.toString();
-                if (output.includes('running on stdio')) {
-                    assert.ok(true, 'Server started despite invalid DB');
-                    clearTimeout(timeout);
-                    server.kill();
-                    resolve();
-                }
-            });
-        });
-    });
-});

package/tests/test-helpers.js

@@ -1,50 +0,0 @@
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { WorkflowState } from "../workflow-state.js";
-import { shellEscape } from "../utils.js";
-import { determineReleaseTypeFromCommit, createCommitMessageParts } from "../commit-helpers.js";
-
-export async function withWorkflowState(callback) {
-  const tempDir = await mkdtemp(path.join(tmpdir(), "workflow-handlers-"));
-  const stateFile = path.join(tempDir, "state.json");
-  const state = new WorkflowState(stateFile);
-  await state.load();
-
-  try {
-    await callback(state);
-  } finally {
-    await rm(tempDir, { recursive: true, force: true });
-  }
-}
-
-export const testUtils = {
-  shellEscape,
-  determineReleaseTypeFromCommit,
-  createCommitMessageParts,
-};
-
-export function createRequest(name, args) {
-  return {
-    params: {
-      name,
-      arguments: args,
-    },
-  };
-}
-
-export function createGitMock(overrides = {}) {
-  return {
-    hasWorkingChanges: async () => false,
-    hasStagedChanges: async () => false,
-    hasTestChanges: async () => true,
-    getStagedChanges: async () => [],
-    getCurrentBranch: async () => "main",
-    getPrimaryBranch: async () => "main",
-    getLastCommitMessage: async () => "",
-    getStatusOutput: async () => "",
-    containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
-    workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
-    ...overrides,
-  };
-}