@programinglive/dev-workflow-mcp-server 1.7.10 → 1.7.11

package/.env.example

@@ -0,0 +1,11 @@
+# Database Configuration
+# Supported types: sqlite, mysql, postgres
+DEV_WORKFLOW_DB_TYPE=sqlite
+
+# Connection URLs
+# MySQL Example: mysql://user:password@localhost:3306/database
+# Postgres Example: postgres://user:password@localhost:5432/database
+DEV_WORKFLOW_DB_URL=
+
+# Optional: Override user ID 
+# DEV_WORKFLOW_USER_ID=my-custom-user-id

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [1.7.11](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.7.10...v1.7.11) (2025-12-16)
+
+
+### 📝 Documentation
+
+* fix version status in PRD ([fa7912b](https://github.com/programinglive/dev-workflow-mcp-server/commit/fa7912ba3354a88ce943fbc9a0f34f4bd1936e34))
+
+
+### ✨ Features
+
+* implement .env support and fix mysql date persistence ([096797c](https://github.com/programinglive/dev-workflow-mcp-server/commit/096797c689813f44106a027cfa36e90d3da4bfb4))
+
+
+### ✅ Tests
+
+* comprehensive DB adapter tests, env support, and warning fixes ([44814ff](https://github.com/programinglive/dev-workflow-mcp-server/commit/44814ffcc0a1efbc8e89948de22c3b196834b390))
+
 ### [1.7.10](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.7.9...v1.7.10) (2025-12-16)
 
 

package/README.md

@@ -183,9 +183,23 @@ See [Antigravity Getting Started](./docs/antigravity/GETTING-STARTED.md) for det
 
 ## ⚙️ Configuration
 
-### Database Backend
+### Database Setup
 
-By default, the server uses a local **SQLite** database stored in `.state/dev-workflow.db`. You can switch to **MySQL** or **PostgreSQL** for centralized storage using environment variables.
+The server supports **SQLite** (default), **MySQL**, and **PostgreSQL**.
+
+#### Configuration via `.env`
+1. Copy `.env.example` to `.env`:
+   ```bash
+   cp .env.example .env
+   ```
+2. Edit `.env` with your settings:
+   ```ini
+   DEV_WORKFLOW_DB_TYPE=mysql
+   DEV_WORKFLOW_DB_URL=mysql://user:pass@localhost:3306/db
+   ```
+
+#### Configuration via Environment Variables
+Alternatively, export variables directly:.
 
 | Variable | Description | Default |
 |----------|-------------|---------|
@@ -252,6 +266,33 @@ Add the environment variable in your Windsurf MCP settings:
 ```
 
 
+
+### ✅ Testing
+
+The project uses Node.js native test runner (`node --test`).
+
+```bash
+npm test
+```
+
+This runs:
+- Unit tests for workflow logic
+- Integration tests for `.env` configuration
+- DB Adapter tests (SQLite always; MySQL/Postgres if configured)
+
+#### Testing Database Adapters
+To verify MySQL or PostgreSQL adapters, run tests with the environment variable set:
+
+```bash
+# Test MySQL
+export DEV_WORKFLOW_DB_URL="mysql://root:pass@localhost:3306/test_db"
+node --test tests/db-adapters.test.js
+
+# Test PostgreSQL
+export DEV_WORKFLOW_DB_URL="postgres://postgres:pass@localhost:5432/test_db"
+node --test tests/db-adapters.test.js
+```
+
 ### Scripts
 
 - `npm run build` - Bundle the source into `dist/index.mjs` for distribution

package/db/adapters/mysql.js

@@ -75,6 +75,13 @@ export class MysqlAdapter extends DbAdapter {
         }
     }
 
+    formatDate(date) {
+        // Ensure we have a string in 'YYYY-MM-DD HH:mm:ss' format
+        const d = date ? new Date(date) : new Date();
+        // slice(0, 19) gives YYYY-MM-DDTHH:mm:ss, then replace T with space
+        return d.toISOString().slice(0, 19).replace('T', ' ');
+    }
+
     async insertHistoryEntry(userId, projectPath, entry) {
         await this.connect();
         const normalizedProjectPath = projectPath || '';
@@ -98,7 +105,7 @@ export class MysqlAdapter extends DbAdapter {
             entry.taskDescription,
             entry.taskType,
             entry.commitMessage,
-            entry.timestamp || new Date().toISOString(),
+            this.formatDate(entry.timestamp),
             entry.forced ? 1 : 0,
             entry.forceReason || null,
             entry.dropped ? 1 : 0,
@@ -150,9 +157,9 @@ export class MysqlAdapter extends DbAdapter {
             normalizedProjectPath,
             rows.length,
             JSON.stringify(taskTypes),
-            lastActive,
+            this.formatDate(lastActive),
             JSON.stringify(recentTasks),
-            new Date().toISOString()
+            this.formatDate(new Date())
         ]);
     }
 
@@ -270,7 +277,7 @@ export class MysqlAdapter extends DbAdapter {
             userId,
             normalizedProjectPath,
             JSON.stringify(state),
-            new Date().toISOString()
+            this.formatDate(new Date())
         ]);
     }
 

package/docs/product/PRD.md

@@ -4,7 +4,7 @@
 - **Product**: Development Workflow MCP Server
 - **Prepared by**: Cascade (AI assistant)
 - **Date**: 2025-12-16
-- **Status**: Live v1.6+
+- **Status**: Live v1.7.10
 
 ## 2. Problem Statement
 Developers need structured guidance to maintain disciplined workflows across projects. Existing tooling lacks enforcement of sequential best practices (testing, documentation, release hygiene) and offers limited visibility into historical task execution.
@@ -38,6 +38,10 @@ Developers need structured guidance to maintain disciplined workflows across pro
 - Guard release commands to ensure prerequisites are satisfied.
 - Support `run_full_workflow` for scripted execution of all steps with validation.
 - Web dashboard displays version dynamically from `package.json` via `/api/version` endpoint to stay in sync after releases.
+- [x] **Consolidated CI/CD**: Unified release and publish workflows.
+- [x] **Multi-Database Support**: SQLite, MySQL, and PostgreSQL adapters implemented and verified.
+- [x] **Environment Configuration**: `.env` file support added.
+- [x] **Comprehensive Testing**: Automated tests for DB adapters and environment loading.
 - **Multi-Database Support**: Abstract the storage layer to support:
     - SQLite (default/local)
     - MySQL

package/docs/release-notes/RELEASE_NOTES.md

@@ -4,6 +4,7 @@ Authoritative history of user-visible changes for the Development Workflow MCP S
 
 | Version | Date | Notes |
 |---------|------|-------|
+| 1.7.10 | 2025-12-16 | update release notes and finalize ci config (92ac78a) |
 | 1.7.9 | 2025-12-16 | **ci:** apply official npm trusted publishing config (9256583) |
 | 1.7.8 | 2025-12-16 | **ci:** remove all token config for pure OIDC publishing (d4759cc) |
 | 1.7.7 | 2025-12-16 | **ci:** remove duplicates and apply robust trusted publishing config (eedb661) |
@@ -31,6 +32,14 @@ Authoritative history of user-visible changes for the Development Workflow MCP S
 
 
 
+
+## 1.7.10 – 🧹 Chores
+
+Released on **2025-12-16**.
+
+- update release notes and finalize ci config (92ac78a)
+- update PRD and release notes for v1.7.9 (024b3c2)
+
 ## 1.7.9 – 🐛 Bug Fixes
 
 Released on **2025-12-16**.

package/index.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 
+import "dotenv/config";
+
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@programinglive/dev-workflow-mcp-server",
-  "version": "1.7.10",
+  "version": "1.7.11",
   "description": "MCP server to enforce development workflow discipline",
   "homepage": "https://devworkflow.programinglive.com/",
   "mcpName": "io.github.programinglive/dev-workflow-mcp-server",
@@ -17,7 +17,7 @@
     "dev": "node --watch index.js",
     "start": "node index.js",
     "local": "node index.js",
-    "test": "node --test",
+    "test": "node --no-deprecation --test",
     "check": "node --check index.js",
     "prepare": "husky",
     "postinstall": "node install.js",
@@ -43,6 +43,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
     "better-sqlite3": "^11.8.0",
+    "dotenv": "^17.2.3",
     "esbuild": "^0.25.0",
     "get-port": "^7.1.0",
     "marked": "^12.0.2",

package/tests/db-adapters.test.js

@@ -0,0 +1,108 @@
+import "dotenv/config";
+import test from "node:test";
+import assert from "node:assert/strict";
+import path from "node:path";
+import fs from "node:fs/promises";
+import os from "node:os";
+
+import { SqliteAdapter } from "../db/adapters/sqlite.js";
+import { MysqlAdapter } from "../db/adapters/mysql.js";
+import { PostgresAdapter } from "../db/adapters/postgres.js";
+
+
+// Helper to run common adapter tests
+async function runGenericAdapterTests(t, adapter, testUserId, testProject) {
+    await t.test("connects and migrates", async () => {
+        await adapter.connect();
+        // No error means success
+    });
+
+    await t.test("inserts and retrieves history", async () => {
+        const entry = {
+            taskDescription: "Test Task",
+            taskType: "feature",
+            commitMessage: "feat: test",
+            timestamp: new Date().toISOString(),
+        };
+        await adapter.insertHistoryEntry(testUserId, testProject, entry);
+
+        const history = await adapter.getHistoryForUser(testUserId, testProject, { pageSize: 1 });
+        assert.equal(history.entries.length, 1);
+        assert.equal(history.entries[0].task_description, "Test Task");
+    });
+
+    await t.test("saves and retrieves state", async () => {
+        const state = { phase: "testing", count: 123 };
+        await adapter.saveState(testUserId, testProject, state);
+        const retrieved = await adapter.getState(testUserId, testProject);
+        assert.deepEqual(retrieved, state);
+    });
+
+    await t.test("history summary aggregation", async () => {
+        // already inserted one entry
+        const summary = await adapter.getHistorySummary(testUserId, testProject, { frequency: 'daily' });
+        assert.ok(summary.length > 0);
+    });
+
+    await t.test("project summary update", async () => {
+        const summary = await adapter.getSummaryForUser(testUserId, testProject);
+        assert.ok(summary);
+        assert.ok(summary.totalTasks >= 1);
+    });
+}
+
+test("Database Adapters", async (t) => {
+    // 1. SQLite (Always Test)
+    await t.test("SqliteAdapter", async (t) => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "sqlite-test-"));
+        const dbPath = path.join(tmpDir, "test.db");
+
+        // Convert to file URI for connection string if needed, or just pass path
+        // The adapter expects a connection URL for SQLite usually: file:///path/to/db or just path?
+        // Looking at sqlite.js: uri: this.config.connectionUrl.replace("sqlite://", "")
+        // So we invoke it with sqlite://<path>
+        const connectionUrl = `sqlite://${dbPath}`;
+
+        const adapter = new SqliteAdapter({ connectionUrl });
+
+        try {
+            await runGenericAdapterTests(t, adapter, "user-sqlite", tmpDir);
+        } finally {
+            if (adapter.db) adapter.db.close();
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+
+    // 2. MySQL (Conditional)
+    // Check specific test variable OR generic one if it maps to mysql
+    const mysqlUrl = process.env.TEST_MYSQL_URL ||
+        (process.env.DEV_WORKFLOW_DB_URL && process.env.DEV_WORKFLOW_DB_URL.startsWith("mysql") ? process.env.DEV_WORKFLOW_DB_URL : null);
+
+    await t.test("MysqlAdapter", { skip: !mysqlUrl }, async (t) => {
+        const adapter = new MysqlAdapter({ connectionUrl: mysqlUrl });
+        try {
+            // We use a random user ID to avoid clashing with verification script data
+            // although verification cleaned up mostly.
+            const testId = `test-mysql-${Date.now()}`;
+            const testProj = process.cwd();
+            await runGenericAdapterTests(t, adapter, testId, testProj);
+        } finally {
+            if (adapter.pool) await adapter.pool.end();
+        }
+    });
+
+    // 3. PostgreSQL (Conditional)
+    const pgUrl = process.env.TEST_POSTGRES_URL ||
+        (process.env.DEV_WORKFLOW_DB_URL && process.env.DEV_WORKFLOW_DB_URL.startsWith("postgres") ? process.env.DEV_WORKFLOW_DB_URL : null);
+
+    await t.test("PostgresAdapter", { skip: !pgUrl }, async (t) => {
+        const adapter = new PostgresAdapter({ connectionUrl: pgUrl });
+        try {
+            const testId = `test-pg-${Date.now()}`;
+            const testProj = process.cwd();
+            await runGenericAdapterTests(t, adapter, testId, testProj);
+        } finally {
+            if (adapter.pool) await adapter.pool.end();
+        }
+    });
+});

package/tests/env-support.test.js

@@ -0,0 +1,46 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import path from "node:path";
+import fs from "node:fs/promises";
+import os from "node:os";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { pathToFileURL } from "node:url";
+
+const execAsync = promisify(exec);
+
+test("Environment Configuration", async (t) => {
+    await t.test("loads variables from .env file", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "env-test-"));
+        const originalCwd = process.cwd();
+        const indexJsPath = path.resolve(originalCwd, "index.js");
+        const indexUrl = pathToFileURL(indexJsPath).href;
+
+        try {
+            // Create a .env file
+            await fs.writeFile(path.join(tmpDir, ".env"), "TEST_ENV_VAR=loaded_successfully");
+
+            // Verify node can run and load it via index.js import
+            // We import index.js to trigger the 'dotenv/config' import.
+            // Since index.js starts a server if run directly, we just import it.
+            // However, we need to run a script in the NEW CWD.
+
+            const script = `
+        import '${indexUrl}'; 
+        console.log("VAR:" + process.env.TEST_ENV_VAR);
+        process.exit(0);
+      `;
+
+            const scriptPath = path.join(tmpDir, "check_env.js");
+            await fs.writeFile(scriptPath, script);
+
+            // Execute in tmpDir
+            const { stdout } = await execAsync(`node check_env.js`, { cwd: tmpDir });
+
+            assert.ok(stdout.includes("VAR:loaded_successfully"), "Output should contain loaded variable");
+
+        } finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+});

package/tests/workflowState.test.js

@@ -14,6 +14,13 @@ import { constants as fsConstants } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+
+// Isolate these tests from the real database configuration
+delete process.env.DEV_WORKFLOW_DB_TYPE;
+delete process.env.DEV_WORKFLOW_DB_URL;
+delete process.env.TEST_MYSQL_URL;
+delete process.env.TEST_POSTGRES_URL;
+
 import {
   WorkflowState,
   getNextStep,
@@ -50,7 +57,9 @@ test("resolveStateFile prefers current working directory when multiple project m
   const sourceModulePath = fileURLToPath(new URL("../workflow-state.js", import.meta.url));
   await copyFile(sourceModulePath, path.join(moduleDir, "workflow-state.js"));
 
-  await writeFile(path.join(moduleDir, "package.json"), JSON.stringify({ name: "module" }));
+  await writeFile(path.join(moduleDir, "package.json"), JSON.stringify({ name: "module", type: "module" }));
+  await mkdir(path.join(moduleDir, "db"), { recursive: true });
+  await writeFile(path.join(moduleDir, "db", "index.js"), 'export function getDbAdapter() { return { connect: async () => {}, saveState: async () => {}, getState: async () => null }; } export async function insertHistoryEntry() {} export async function updateSummaryForUser() {} export async function saveState() {} export async function getState() {} export async function getSummaryForUser() { return { totalTasks: 0, taskTypes: {} }; } export async function getHistoryForUser() { return { entries: [], total: 0 }; }');
   await writeFile(path.join(projectA, "package.json"), JSON.stringify({ name: "project-a" }));
   await writeFile(path.join(projectB, "package.json"), JSON.stringify({ name: "project-b" }));
 
@@ -101,6 +110,9 @@ test("WorkflowState mirrors state file to compatibility locations", async () =>
   await mkdir(path.join(tempRoot, "dist"), { recursive: true });
   await mkdir(stateDir, { recursive: true });
   await copyFile(sourceModulePath, path.join(moduleDir, "workflow-state.js"));
+  await writeFile(path.join(moduleDir, "package.json"), JSON.stringify({ name: "module", type: "module" }));
+  await mkdir(path.join(moduleDir, "db"), { recursive: true });
+  await writeFile(path.join(moduleDir, "db", "index.js"), 'export function getDbAdapter() { return { connect: async () => {}, saveState: async () => {}, getState: async () => null }; } export async function insertHistoryEntry() {} export async function updateSummaryForUser() {} export async function saveState() {} export async function getState() {} export async function getSummaryForUser() { return { totalTasks: 0, taskTypes: {} }; } export async function getHistoryForUser() { return { entries: [], total: 0 }; }');
   await writeFile(path.join(projectRoot, "package.json"), JSON.stringify({ name: "temp" }));
 
   const stateFile = path.join(stateDir, "workflow-state.json");
@@ -129,6 +141,9 @@ test("WorkflowState avoids filesystem root when no project markers found", async
 
   const sourceModulePath = fileURLToPath(new URL("../workflow-state.js", import.meta.url));
   await copyFile(sourceModulePath, path.join(moduleDir, "workflow-state.js"));
+  await writeFile(path.join(moduleDir, "package.json"), JSON.stringify({ name: "module", type: "module" }));
+  await mkdir(path.join(moduleDir, "db"), { recursive: true });
+  await writeFile(path.join(moduleDir, "db", "index.js"), 'export function getDbAdapter() { return { connect: async () => {}, saveState: async () => {}, getState: async () => null }; } export async function insertHistoryEntry() {} export async function updateSummaryForUser() {} export async function saveState() {} export async function getState() {} export async function getSummaryForUser() { return { totalTasks: 0, taskTypes: {} }; } export async function getHistoryForUser() { return { entries: [], total: 0 }; }');
 
   const moduleUrl = pathToFileURL(path.join(moduleDir, "workflow-state.js"));
   const { WorkflowState: TempWorkflowState } = await import(moduleUrl.href);

package/verify-db-mysql.js

@@ -0,0 +1,92 @@
+
+import { MysqlAdapter } from "./db/adapters/mysql.js";
+import { resolve } from "path";
+
+const CONNECTION_URL = process.env.DEV_WORKFLOW_DB_URL;
+
+if (!CONNECTION_URL) {
+    console.error("❌ Error: DEV_WORKFLOW_DB_URL environment variable is required.");
+    console.error("Usage: DEV_WORKFLOW_DB_URL='mysql://user:password@host:port/database' node verify-db-mysql.js");
+    process.exit(1);
+}
+
+const TEST_USER = "test-verification-user";
+const TEST_PROJECT = resolve(process.cwd());
+
+async function runVerification() {
+    console.log("🔍 Starting MySQL Verification...");
+    console.log(`   User ID: ${TEST_USER}`);
+    console.log(`   Project: ${TEST_PROJECT}`);
+    console.log(`   URL:     ${CONNECTION_URL.replace(/:[^:@]+@/, ":****@")}`);
+
+    const adapter = new MysqlAdapter({
+        connectionUrl: CONNECTION_URL
+    });
+
+    try {
+        // 1. Connect & Migrate
+        console.log("\n1. Connecting and Migrating...");
+        await adapter.connect();
+        console.log("   ✅ Connected to MySQL");
+
+        // 2. Clear previous test data (optional, but good for cleanliness)
+        // We won't strictly clear to avoid wiping valid data if user reuses IDs, 
+        // but the test user should be unique enough.
+
+        // 3. Insert History
+        console.log("\n3. Testing History Insertion...");
+        const entry = {
+            taskDescription: "Verification Task",
+            taskType: "test",
+            timestamp: new Date().toISOString(),
+            commitMessage: "test commit"
+        };
+        await adapter.insertHistoryEntry(TEST_USER, TEST_PROJECT, entry);
+        console.log("   ✅ Inserted history entry");
+
+        // 4. Verify History Retrieval
+        console.log("\n4. Verifying History Retrieval...");
+        const history = await adapter.getHistoryForUser(TEST_USER, TEST_PROJECT, { pageSize: 1 });
+        const savedEntry = history.entries[0];
+
+        if (savedEntry && savedEntry.task_description === entry.taskDescription) {
+            console.log("   ✅ Retrieved history entry matches");
+        } else {
+            console.error("   ❌ Retrieved entry mismatch:", savedEntry);
+            process.exit(1);
+        }
+
+        // 5. Test State Persistence
+        console.log("\n5. Testing State Persistence...");
+        const state = {
+            currentPhase: "verification",
+            verified: true,
+            random: Math.random()
+        };
+        await adapter.saveState(TEST_USER, TEST_PROJECT, state);
+        console.log("   ✅ Saved state");
+
+        // 6. Verify State Retrieval
+        console.log("\n6. Verifying State Retrieval...");
+        const retrievedState = await adapter.getState(TEST_USER, TEST_PROJECT);
+        if (retrievedState && retrievedState.random === state.random) {
+            console.log("   ✅ Retrieved state matches");
+        } else {
+            console.error("   ❌ Retrieved state mismatch:", retrievedState);
+            process.exit(1);
+        }
+
+        console.log("\n🎉 MySQL Verification SUCCESS!");
+        process.exit(0);
+
+    } catch (error) {
+        console.error("\n❌ Verification FAILED:", error);
+        process.exit(1);
+    } finally {
+        if (adapter.pool) {
+            await adapter.pool.end();
+        }
+    }
+}
+
+runVerification();