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

package/db/adapters/postgres.js

@@ -0,0 +1,291 @@
+import pg from "pg";
+import { DbAdapter } from "./base.js";
+
+const { Pool } = pg;
+
+const FREQUENCY_FORMATS = {
+    daily: "YYYY-MM-DD",
+    monthly: "YYYY-MM",
+    yearly: "YYYY",
+};
+
+export class PostgresAdapter extends DbAdapter {
+    constructor(config = {}) {
+        super(config);
+        this.pool = null;
+    }
+
+    async connect() {
+        if (!this.pool) {
+            this.pool = new Pool({
+                connectionString: this.config.connectionUrl,
+                // pg pool handles connections automatically
+            });
+            await this.migrate();
+        }
+    }
+
+    async migrate() {
+        const client = await this.pool.connect();
+        try {
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS workflow_history (
+          id SERIAL PRIMARY KEY,
+          user_id TEXT NOT NULL,
+          project_path TEXT DEFAULT '',
+          task_description TEXT NOT NULL,
+          task_type TEXT NOT NULL,
+          commit_message TEXT,
+          timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+          forced BOOLEAN DEFAULT FALSE,
+          force_reason TEXT,
+          dropped BOOLEAN DEFAULT FALSE,
+          drop_reason TEXT,
+          UNIQUE (user_id, project_path, timestamp, task_description)
+        )
+      `);
+
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS project_summary (
+          user_id TEXT,
+          project_path TEXT DEFAULT '',
+          total_tasks INTEGER DEFAULT 0,
+          task_types JSONB,
+          last_active TIMESTAMP,
+          updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+          recent_tasks JSONB,
+          PRIMARY KEY (user_id, project_path)
+        )
+      `);
+
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS workflow_state (
+          user_id TEXT,
+          project_path TEXT DEFAULT '',
+          state_json JSONB,
+          updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+          PRIMARY KEY (user_id, project_path)
+        )
+      `);
+        } finally {
+            client.release();
+        }
+    }
+
+    async insertHistoryEntry(userId, projectPath, entry) {
+        await this.connect();
+        const normalizedProjectPath = projectPath || '';
+
+        const query = `
+      INSERT INTO workflow_history
+      (user_id, project_path, task_description, task_type, commit_message, timestamp, forced, force_reason, dropped, drop_reason)
+      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+      ON CONFLICT (user_id, project_path, timestamp, task_description) DO UPDATE SET
+        commit_message=EXCLUDED.commit_message,
+        forced=EXCLUDED.forced,
+        force_reason=EXCLUDED.force_reason,
+        dropped=EXCLUDED.dropped,
+        drop_reason=EXCLUDED.drop_reason
+    `;
+
+        await this.pool.query(query, [
+            userId,
+            normalizedProjectPath,
+            entry.taskDescription,
+            entry.taskType,
+            entry.commitMessage,
+            entry.timestamp || new Date().toISOString(),
+            entry.forced || false,
+            entry.forceReason || null,
+            entry.dropped || false,
+            entry.dropReason || null
+        ]);
+
+        await this.updateSummaryForUser(userId, normalizedProjectPath);
+    }
+
+    async updateSummaryForUser(userId, projectPath) {
+        await this.connect();
+        const normalizedProjectPath = projectPath || '';
+
+        const res = await this.pool.query(`
+      SELECT task_type, timestamp, task_description
+      FROM workflow_history
+      WHERE user_id = $1 AND project_path = $2
+      ORDER BY timestamp DESC
+      LIMIT 20
+    `, [userId, normalizedProjectPath]);
+
+        const rows = res.rows;
+
+        const taskTypes = {};
+        for (const row of rows) {
+            taskTypes[row.task_type] = (taskTypes[row.task_type] || 0) + 1;
+        }
+
+        const recentTasks = rows.slice(0, 5).map(r => ({
+            description: r.task_description,
+            type: r.task_type,
+            timestamp: r.timestamp,
+        }));
+
+        const lastActive = rows[0]?.timestamp || null;
+
+        const upsert = `
+      INSERT INTO project_summary
+      (user_id, project_path, total_tasks, task_types, last_active, recent_tasks, updated_at)
+      VALUES ($1, $2, $3, $4, $5, $6, $7)
+      ON CONFLICT (user_id, project_path) DO UPDATE SET
+        total_tasks=EXCLUDED.total_tasks,
+        task_types=EXCLUDED.task_types,
+        last_active=EXCLUDED.last_active,
+        recent_tasks=EXCLUDED.recent_tasks,
+        updated_at=EXCLUDED.updated_at
+    `;
+
+        await this.pool.query(upsert, [
+            userId,
+            normalizedProjectPath,
+            rows.length,
+            JSON.stringify(taskTypes),
+            lastActive,
+            JSON.stringify(recentTasks),
+            new Date().toISOString()
+        ]);
+    }
+
+    async getSummaryForUser(userId, projectPath) {
+        await this.connect();
+        const normalizedProjectPath = projectPath || '';
+
+        const res = await this.pool.query(`
+      SELECT * FROM project_summary WHERE user_id = $1 AND project_path = $2
+    `, [userId, normalizedProjectPath]);
+
+        const row = res.rows[0];
+        if (!row) return null;
+
+        return {
+            totalTasks: row.total_tasks,
+            taskTypes: row.task_types, // pg parses jsonb automatically
+            lastActive: row.last_active,
+            recentTasks: row.recent_tasks,
+            updatedAt: row.updated_at,
+        };
+    }
+
+    async getHistoryForUser(userId, projectPath, options = {}) {
+        await this.connect();
+        const normalizedProjectPath = projectPath || '';
+
+        const { page = 1, pageSize = 20, startDate, endDate } = options;
+        const sanitizedPage = Math.max(1, Number.isFinite(Number(page)) ? Math.floor(Number(page)) : 1);
+        const sanitizedPageSize = Math.min(100, Math.max(1, Number.isFinite(Number(pageSize)) ? Math.floor(Number(pageSize)) : 20));
+        const offset = (sanitizedPage - 1) * sanitizedPageSize;
+
+        const clauses = [];
+        const params = [userId, normalizedProjectPath];
+        let paramIdx = 3;
+
+        if (startDate) {
+            clauses.push(`DATE(timestamp) >= DATE($${paramIdx++})`);
+            params.push(startDate);
+        }
+        if (endDate) {
+            clauses.push(`DATE(timestamp) <= DATE($${paramIdx++})`);
+            params.push(endDate);
+        }
+
+        const where = [`user_id = $1`, `project_path = $2`, ...clauses].join(" AND ");
+
+        const countRes = await this.pool.query(
+            `SELECT COUNT(*) as total FROM workflow_history WHERE ${where}`,
+            params
+        );
+        const total = parseInt(countRes.rows[0].total, 10);
+
+        const entriesRes = await this.pool.query(`
+      SELECT *
+      FROM workflow_history
+      WHERE ${where}
+      ORDER BY timestamp DESC
+      LIMIT $${paramIdx++}
+      OFFSET $${paramIdx++}
+    `, [...params, sanitizedPageSize, offset]);
+
+        return {
+            entries: entriesRes.rows,
+            total,
+            page: sanitizedPage,
+            pageSize: sanitizedPageSize,
+        };
+    }
+
+    async getHistorySummary(userId, projectPath, options = {}) {
+        await this.connect();
+        const normalizedProjectPath = projectPath || '';
+
+        const { startDate, endDate, frequency = "daily" } = options;
+        const format = FREQUENCY_FORMATS[frequency] || FREQUENCY_FORMATS.daily;
+
+        const clauses = [];
+        const params = [userId, normalizedProjectPath];
+        let paramIdx = 3;
+
+        if (startDate) {
+            clauses.push(`DATE(timestamp) >= DATE($${paramIdx++})`);
+            params.push(startDate);
+        }
+        if (endDate) {
+            clauses.push(`DATE(timestamp) <= DATE($${paramIdx++})`);
+            params.push(endDate);
+        }
+
+        const where = [`user_id = $1`, `project_path = $2`, ...clauses].join(" AND ");
+
+        const res = await this.pool.query(`
+      SELECT to_char(timestamp, '${format}') AS period, COUNT(*) AS count
+      FROM workflow_history
+      WHERE ${where}
+      GROUP BY period
+      ORDER BY period DESC
+    `, params);
+
+        return res.rows;
+    }
+
+    async saveState(userId, projectPath, state) {
+        await this.connect();
+        const normalizedProjectPath = projectPath || '';
+
+        const query = `
+      INSERT INTO workflow_state
+      (user_id, project_path, state_json, updated_at)
+      VALUES ($1, $2, $3, $4)
+      ON CONFLICT (user_id, project_path) DO UPDATE SET
+        state_json=EXCLUDED.state_json,
+        updated_at=EXCLUDED.updated_at
+    `;
+
+        await this.pool.query(query, [
+            userId,
+            normalizedProjectPath,
+            JSON.stringify(state),
+            new Date().toISOString()
+        ]);
+    }
+
+    async getState(userId, projectPath) {
+        await this.connect();
+        const normalizedProjectPath = projectPath || '';
+
+        const res = await this.pool.query(`
+      SELECT state_json FROM workflow_state WHERE user_id = $1 AND project_path = $2
+    `, [userId, normalizedProjectPath]);
+
+        const row = res.rows[0];
+        if (!row) return null;
+
+        return row.state_json; // pg automatically parses JSONB
+    }
+}

package/db/adapters/sqlite.js

@@ -0,0 +1,343 @@
+import Database from "better-sqlite3";
+import { existsSync } from "fs";
+import path from "path";
+import { DbAdapter } from "./base.js";
+
+const DB_FILENAME = "dev-workflow.db";
+const FREQUENCY_FORMATS = {
+    daily: "%Y-%m-%d",
+    monthly: "%Y-%m",
+    yearly: "%Y",
+};
+
+export class SqliteAdapter extends DbAdapter {
+    constructor(config = {}) {
+        super(config);
+        this.db = null;
+    }
+
+    getDbPath() {
+        // If a specific path is provided in config, use it
+        if (this.config.dbPath) {
+            return this.config.dbPath;
+        }
+
+        // Otherwise, attempt to find project root relative to CWD
+        const initCwd = process.env.INIT_CWD || process.cwd();
+        let projectRoot = initCwd;
+        while (projectRoot !== path.dirname(projectRoot)) {
+            if (existsSync(path.join(projectRoot, "package.json"))) break;
+            projectRoot = path.dirname(projectRoot);
+        }
+        return path.join(projectRoot, ".state", DB_FILENAME);
+    }
+
+    async connect() {
+        if (!this.db) {
+            const dbPath = this.getDbPath();
+            this.db = new Database(dbPath);
+            this.db.pragma("journal_mode = WAL");
+            await this.migrate();
+        }
+    }
+
+    async migrate() {
+        // 1. Create tables if they don't exist (new installs get the correct schema immediately)
+        const createHistory = `
+      CREATE TABLE IF NOT EXISTS workflow_history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        user_id TEXT NOT NULL,
+        project_path TEXT DEFAULT '',
+        task_description TEXT NOT NULL,
+        task_type TEXT NOT NULL,
+        commit_message TEXT,
+        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+        forced INTEGER DEFAULT 0,
+        force_reason TEXT,
+        dropped INTEGER DEFAULT 0,
+        drop_reason TEXT,
+        UNIQUE(user_id, project_path, timestamp, task_description)
+      )
+    `;
+        // Note: project_summary definition
+        const createSummary = `
+      CREATE TABLE IF NOT EXISTS project_summary (
+        user_id TEXT,
+        project_path TEXT DEFAULT '',
+        total_tasks INTEGER DEFAULT 0,
+        task_types TEXT DEFAULT '{}',
+        last_active DATETIME,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        recent_tasks TEXT DEFAULT '[]',
+        PRIMARY KEY (user_id, project_path)
+      )
+    `;
+        const createState = `
+      CREATE TABLE IF NOT EXISTS workflow_state (
+        user_id TEXT,
+        project_path TEXT DEFAULT '',
+        state_json TEXT NOT NULL,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY (user_id, project_path)
+      )
+    `;
+
+        this.db.exec(createHistory);
+
+        // 2. MIGRATION: Handle existing databases (workflow_history)
+        try {
+            const tableInfo = this.db.prepare("PRAGMA table_info(workflow_history)").all();
+            if (!tableInfo.some(col => col.name === 'project_path')) {
+                // Add column to existing table
+                this.db.exec("ALTER TABLE workflow_history ADD COLUMN project_path TEXT DEFAULT ''");
+
+                // Re-create index to include new column
+                this.db.exec("DROP INDEX IF EXISTS idx_workflow_history_user");
+                // We need to fix the UNIQUE constraint if possible, but SQLite ALTER TABLE limitations make that hard.
+                // For now, ensuring the column exists allows the new INSERT logic (inserting '') to work.
+                // Duplicate entries from old schema (with no project_path) effectively mean project_path='' which matches new default.
+            }
+        } catch (e) {
+            console.error("Migration error (workflow_history):", e.message);
+        }
+
+        // 3. MIGRATION: Handle project_summary (Drop and Recreate if schema mismatch)
+        // Since it's a cache and we're changing the Primary Key, it's safer/easier to just drop it.
+        let recreateSummary = false;
+        try {
+            const summaryInfo = this.db.prepare("PRAGMA table_info(project_summary)").all();
+            // If table exists but missing project_path, drop it
+            if (summaryInfo.length > 0 && !summaryInfo.some(col => col.name === 'project_path')) {
+                this.db.exec("DROP TABLE IF EXISTS project_summary");
+                recreateSummary = true;
+            }
+        } catch (e) {
+            // Ignore
+        }
+
+        this.db.exec(createSummary); // Will create if we dropped it or if it didn't exist
+        this.db.exec(createState);
+
+        // 4. Create Indexes (Safe now that columns exist)
+        const idxHistory = `CREATE INDEX IF NOT EXISTS idx_workflow_history_user_project ON workflow_history(user_id, project_path)`;
+        const idxSummary = `CREATE INDEX IF NOT EXISTS idx_project_summary_user_project ON project_summary(user_id, project_path)`;
+
+        // START FIX: Create explicit UNIQUE index to support ON CONFLICT clause for migrated tables
+        // The original table constraint was UNIQUE(user_id, timestamp, task_description).
+        // The new Insert statement relies on UNIQUE(user_id, project_path, timestamp, task_description).
+        // We must ensure this index exists for ON CONFLICT to work.
+        const idxUnique = `CREATE UNIQUE INDEX IF NOT EXISTS idx_workflow_history_entry_v2 ON workflow_history(user_id, project_path, timestamp, task_description)`;
+        // END FIX
+
+        this.db.exec(idxHistory);
+        this.db.exec(idxSummary);
+        this.db.exec(idxUnique);
+    }
+
+    async insertHistoryEntry(userId, projectPath, entry) {
+        await this.connect();
+        const normalizedProjectPath = projectPath || '';
+
+        // SQLite upsert syntax
+        const stmt = this.db.prepare(`
+      INSERT INTO workflow_history
+      (user_id, project_path, task_description, task_type, commit_message, timestamp, forced, force_reason, dropped, drop_reason)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(user_id, project_path, timestamp, task_description) DO UPDATE SET
+        commit_message=excluded.commit_message,
+        forced=excluded.forced,
+        force_reason=excluded.force_reason,
+        dropped=excluded.dropped,
+        drop_reason=excluded.drop_reason
+    `);
+
+        stmt.run(
+            userId,
+            normalizedProjectPath,
+            entry.taskDescription,
+            entry.taskType,
+            entry.commitMessage,
+            entry.timestamp || new Date().toISOString(),
+            entry.forced ? 1 : 0,
+            entry.forceReason || null,
+            entry.dropped ? 1 : 0,
+            entry.dropReason || null
+        );
+
+        await this.updateSummaryForUser(userId, normalizedProjectPath);
+    }
+
+    async updateSummaryForUser(userId, projectPath) {
+        await this.connect();
+        const normalizedProjectPath = projectPath || '';
+
+        const getHistory = this.db.prepare(`
+      SELECT task_type, timestamp, task_description
+      FROM workflow_history
+      WHERE user_id = ? AND project_path = ?
+      ORDER BY timestamp DESC
+      LIMIT 20
+    `);
+        const rows = getHistory.all(userId, normalizedProjectPath);
+
+        const taskTypes = {};
+        for (const row of rows) {
+            taskTypes[row.task_type] = (taskTypes[row.task_type] || 0) + 1;
+        }
+
+        const recentTasks = rows.slice(0, 5).map(r => ({
+            description: r.task_description,
+            type: r.task_type,
+            timestamp: r.timestamp,
+        }));
+
+        const lastActive = rows[0]?.timestamp || null;
+
+        const upsert = this.db.prepare(`
+      INSERT INTO project_summary
+      (user_id, project_path, total_tasks, task_types, last_active, recent_tasks, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(user_id, project_path) DO UPDATE SET
+        total_tasks=excluded.total_tasks,
+        task_types=excluded.task_types,
+        last_active=excluded.last_active,
+        recent_tasks=excluded.recent_tasks,
+        updated_at=excluded.updated_at
+    `);
+
+        upsert.run(
+            userId,
+            normalizedProjectPath,
+            rows.length,
+            JSON.stringify(taskTypes),
+            lastActive,
+            JSON.stringify(recentTasks),
+            new Date().toISOString()
+        );
+    }
+
+    async getSummaryForUser(userId, projectPath) {
+        await this.connect();
+        const normalizedProjectPath = projectPath || '';
+
+        const stmt = this.db.prepare(`
+      SELECT * FROM project_summary WHERE user_id = ? AND project_path = ?
+    `);
+        const row = stmt.get(userId, normalizedProjectPath);
+
+        if (!row) return null;
+        return {
+            totalTasks: row.total_tasks,
+            taskTypes: JSON.parse(row.task_types),
+            lastActive: row.last_active,
+            recentTasks: JSON.parse(row.recent_tasks),
+            updatedAt: row.updated_at,
+        };
+    }
+
+    buildHistoryFilters({ startDate, endDate }) {
+        const clauses = [];
+        const params = [];
+        if (startDate) {
+            clauses.push("DATE(timestamp) >= DATE(?)");
+            params.push(startDate);
+        }
+        if (endDate) {
+            clauses.push("DATE(timestamp) <= DATE(?)");
+            params.push(endDate);
+        }
+        return { clauses, params };
+    }
+
+    async getHistoryForUser(userId, projectPath, options = {}) {
+        await this.connect();
+        const normalizedProjectPath = projectPath || '';
+
+        const { page = 1, pageSize = 20, startDate, endDate } = options;
+        const sanitizedPage = Math.max(1, Number.isFinite(Number(page)) ? Math.floor(Number(page)) : 1);
+        const sanitizedPageSize = Math.min(100, Math.max(1, Number.isFinite(Number(pageSize)) ? Math.floor(Number(pageSize)) : 20));
+        const offset = (sanitizedPage - 1) * sanitizedPageSize;
+
+        const { clauses, params } = this.buildHistoryFilters({ startDate, endDate });
+        const where = ["user_id = ?", "project_path = ?", ...clauses].join(" AND ");
+
+        const countStmt = this.db.prepare(`SELECT COUNT(*) as total FROM workflow_history WHERE ${where}`);
+        const total = countStmt.get(userId, normalizedProjectPath, ...params).total;
+
+        const rowsStmt = this.db.prepare(`
+      SELECT *
+      FROM workflow_history
+      WHERE ${where}
+      ORDER BY timestamp DESC
+      LIMIT ?
+      OFFSET ?
+    `);
+        const entries = rowsStmt.all(userId, normalizedProjectPath, ...params, sanitizedPageSize, offset);
+
+        return {
+            entries,
+            total,
+            page: sanitizedPage,
+            pageSize: sanitizedPageSize,
+        };
+    }
+
+    async getHistorySummary(userId, projectPath, options = {}) {
+        await this.connect();
+        const normalizedProjectPath = projectPath || '';
+
+        const { startDate, endDate, frequency = "daily" } = options;
+        const format = FREQUENCY_FORMATS[frequency] || FREQUENCY_FORMATS.daily;
+        const { clauses, params } = this.buildHistoryFilters({ startDate, endDate });
+        const where = ["user_id = ?", "project_path = ?", ...clauses].join(" AND ");
+
+        const stmt = this.db.prepare(`
+      SELECT strftime('${format}', timestamp) AS period, COUNT(*) AS count
+      FROM workflow_history
+      WHERE ${where}
+      GROUP BY period
+      ORDER BY period DESC
+    `);
+
+        return stmt
+            .all(userId, normalizedProjectPath, ...params)
+            .map((row) => ({ period: row.period, count: row.count }));
+    }
+
+    async saveState(userId, projectPath, state) {
+        await this.connect();
+        const normalizedProjectPath = projectPath || '';
+
+        const stmt = this.db.prepare(`
+      INSERT INTO workflow_state (user_id, project_path, state_json, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(user_id, project_path) DO UPDATE SET
+        state_json=excluded.state_json,
+        updated_at=excluded.updated_at
+    `);
+
+        stmt.run(
+            userId,
+            normalizedProjectPath,
+            JSON.stringify(state),
+            new Date().toISOString()
+        );
+    }
+
+    async getState(userId, projectPath) {
+        await this.connect();
+        const normalizedProjectPath = projectPath || '';
+
+        const stmt = this.db.prepare(`
+      SELECT state_json FROM workflow_state WHERE user_id = ? AND project_path = ?
+    `);
+        const row = stmt.get(userId, normalizedProjectPath);
+
+        if (!row) return null;
+        try {
+            return JSON.parse(row.state_json);
+        } catch {
+            return null;
+        }
+    }
+}