@sureshdsk/devflow-mcp 3.0.0 → 3.0.1

package/.next/standalone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sureshdsk/devflow-mcp",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Context-First Kanban for AI Agents - MCP server with web UI for managing AI agent workflows",
   "author": "DevFlow Team",
   "license": "MIT",
@@ -47,11 +47,20 @@
     "typecheck": "tsc --noEmit",
     "db:generate": "drizzle-kit generate",
     "db:push": "drizzle-kit push",
-    "db:studio": "drizzle-kit studio",
     "db:init": "node scripts/init-db.js",
     "mcp": "bun src/mcp/server.ts",
     "prepublishOnly": "npm run typecheck && npm run lint && npm run build",
-    "postinstall": "node scripts/postinstall.js"
+    "postinstall": "node scripts/postinstall.js",
+    "prepare": "husky"
+  },
+  "lint-staged": {
+    "*.{ts,tsx}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "*.{js,json,css,md}": [
+      "prettier --write"
+    ]
   },
   "dependencies": {
     "@dnd-kit/core": "^6.3.1",
@@ -59,13 +68,10 @@
     "@dnd-kit/utilities": "^3.2.2",
     "@libsql/client": "^0.17.0",
     "@modelcontextprotocol/sdk": "^1.25.3",
-    "@radix-ui/react-collapsible": "^1.1.12",
     "@radix-ui/react-dialog": "^1.1.15",
     "@radix-ui/react-dropdown-menu": "^2.1.16",
-    "@radix-ui/react-select": "^2.2.6",
     "@radix-ui/react-slot": "^1.2.4",
-    "@radix-ui/react-tabs": "^1.1.13",
-    "@radix-ui/react-toast": "^1.2.15",
+    "@tanstack/react-query": "^5.90.21",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "drizzle-orm": "^0.45.1",
@@ -92,6 +98,9 @@
     "drizzle-kit": "^0.31.8",
     "eslint": "^9.39.1",
     "eslint-config-next": "^16.0.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "prettier": "^3.8.1",
     "tailwindcss": "^4.1.17",
     "typescript": "^5.9.3"
   }

package/.next/standalone/postcss.config.mjs

@@ -1,5 +1,5 @@
 const config = {
-  plugins: ["@tailwindcss/postcss"],
+  plugins: ['@tailwindcss/postcss'],
 };
 
 export default config;

package/.next/standalone/scripts/init-db.js

@@ -54,9 +54,7 @@ async function chooseSchemaTemplate(projectRoot, options) {
     availableSchemaIds,
     interactive,
     confirmKeepExisting: async (current) => {
-      const answer = await askQuestion(
-        `Current default schema is "${current}". Keep it? [Y/n]: `
-      );
+      const answer = await askQuestion(`Current default schema is "${current}". Keep it? [Y/n]: `);
       return answer === '' || /^y(es)?$/i.test(answer);
     },
     promptSelectSchema: async (ids, current) => {
@@ -84,7 +82,7 @@ async function chooseSchemaTemplate(projectRoot, options) {
   return {
     schemaId: result.schemaId,
     reason: result.reason,
-    configPath: path.join(projectRoot, '.devflow', 'project-config.json'),
+    configPath: path.join(projectRoot, 'devflow', 'project-config.json'),
   };
 }
 
@@ -110,7 +108,7 @@ async function initDatabase(options = {}) {
 
   // If DB has old schema (features table), drop and recreate
   const tables = await client.execute(
-    `SELECT name FROM sqlite_master WHERE type='table' AND name='features'`
+    `SELECT name FROM sqlite_master WHERE type='table' AND name='features'`,
   );
   if (tables.rows.length > 0) {
     console.log('⚠ Detected old schema (features table). Recreating database...');

package/.next/standalone/scripts/init-db.test.js

@@ -1,10 +1,10 @@
-const test = require("node:test");
-const assert = require("node:assert/strict");
+const test = require('node:test');
+const assert = require('node:assert/strict');
 
-const { parseInitArgs } = require("./init-db");
+const { parseInitArgs } = require('./init-db');
 
-test("parseInitArgs parses schema and non-interactive flags", () => {
-  const parsed = parseInitArgs(["--schema", "backend-api", "--non-interactive"]);
-  assert.equal(parsed.schema, "backend-api");
+test('parseInitArgs parses schema and non-interactive flags', () => {
+  const parsed = parseInitArgs(['--schema', 'backend-api', '--non-interactive']);
+  assert.equal(parsed.schema, 'backend-api');
   assert.equal(parsed.nonInteractive, true);
 });

package/.next/standalone/scripts/init-schema.js

@@ -1,16 +1,16 @@
-const fs = require("fs");
-const path = require("path");
-const yaml = require("js-yaml");
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
 
 function getProjectConfigPath(projectRoot) {
-  return path.join(projectRoot, ".devflow", "project-config.json");
+  return path.join(projectRoot, 'devflow', 'project-config.json');
 }
 
 function readProjectConfig(projectRoot) {
   const configPath = getProjectConfigPath(projectRoot);
   if (!fs.existsSync(configPath)) return {};
   try {
-    return JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
   } catch {
     return {};
   }
@@ -19,7 +19,7 @@ function readProjectConfig(projectRoot) {
 function writeProjectConfig(projectRoot, config) {
   const configPath = getProjectConfigPath(projectRoot);
   fs.mkdirSync(path.dirname(configPath), { recursive: true });
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
 }
 
 function readSchemasFromDir(baseDir, source) {
@@ -31,9 +31,9 @@ function readSchemasFromDir(baseDir, source) {
 
   const schemas = [];
   for (const entryName of entries) {
-    const schemaPath = path.join(baseDir, entryName, "schema.yaml");
+    const schemaPath = path.join(baseDir, entryName, 'schema.yaml');
     if (!fs.existsSync(schemaPath)) continue;
-    const parsed = yaml.load(fs.readFileSync(schemaPath, "utf-8")) || {};
+    const parsed = yaml.load(fs.readFileSync(schemaPath, 'utf-8')) || {};
     if (!parsed.name) {
       throw new Error(`Invalid schema at ${schemaPath}: missing name`);
     }
@@ -41,7 +41,7 @@ function readSchemasFromDir(baseDir, source) {
       id: String(parsed.name),
       source,
       schemaPath,
-      templatesDir: path.join(path.dirname(schemaPath), "templates"),
+      templatesDir: path.join(path.dirname(schemaPath), 'templates'),
     });
   }
   return schemas;
@@ -50,11 +50,11 @@ function readSchemasFromDir(baseDir, source) {
 function discoverSchemaTemplates(options) {
   const projectRoot = options.projectRoot;
   const packageRoot = options.packageRoot;
-  const bundledDir = options.bundledDir || path.join(packageRoot, "src", "schemas");
-  const projectSchemaDir = path.join(projectRoot, "schemas");
+  const bundledDir = options.bundledDir || path.join(packageRoot, 'src', 'schemas');
+  const projectSchemaDir = path.join(projectRoot, 'schemas');
 
-  const bundled = readSchemasFromDir(bundledDir, "bundled");
-  const project = readSchemasFromDir(projectSchemaDir, "project");
+  const bundled = readSchemasFromDir(bundledDir, 'bundled');
+  const project = readSchemasFromDir(projectSchemaDir, 'project');
   const merged = [...bundled, ...project];
 
   const idToSchema = new Map();
@@ -62,7 +62,7 @@ function discoverSchemaTemplates(options) {
     const existing = idToSchema.get(schema.id);
     if (existing) {
       throw new Error(
-        `Schema ID conflict for "${schema.id}" between ${existing.source}:${existing.schemaPath} and ${schema.source}:${schema.schemaPath}`
+        `Schema ID conflict for "${schema.id}" between ${existing.source}:${existing.schemaPath} and ${schema.source}:${schema.schemaPath}`,
       );
     }
     idToSchema.set(schema.id, schema);
@@ -74,7 +74,7 @@ function discoverSchemaTemplates(options) {
 function assertKnownSchema(schemaId, availableSchemaIds) {
   if (!availableSchemaIds.includes(schemaId)) {
     throw new Error(
-      `Unknown schema "${schemaId}". Available schemas: ${availableSchemaIds.join(", ")}`
+      `Unknown schema "${schemaId}". Available schemas: ${availableSchemaIds.join(', ')}`,
     );
   }
 }
@@ -91,31 +91,31 @@ async function resolveInitSchemaSelection(options) {
 
   if (requestedSchema) {
     assertKnownSchema(requestedSchema, availableSchemaIds);
-    return { schemaId: requestedSchema, reason: "explicit" };
+    return { schemaId: requestedSchema, reason: 'explicit' };
   }
 
   if (!interactive) {
     if (existingDefaultSchema && availableSchemaIds.includes(existingDefaultSchema)) {
-      return { schemaId: existingDefaultSchema, reason: "existing-default" };
+      return { schemaId: existingDefaultSchema, reason: 'existing-default' };
     }
-    if (availableSchemaIds.includes("spec-driven")) {
-      return { schemaId: "spec-driven", reason: "non-interactive-fallback" };
+    if (availableSchemaIds.includes('spec-driven')) {
+      return { schemaId: 'spec-driven', reason: 'non-interactive-fallback' };
     }
     throw new Error(
-      `Non-interactive init requires a schema. Available schemas: ${availableSchemaIds.join(", ")}`
+      `Non-interactive init requires a schema. Available schemas: ${availableSchemaIds.join(', ')}`,
     );
   }
 
   if (existingDefaultSchema && availableSchemaIds.includes(existingDefaultSchema)) {
     const keep = (await confirmKeepExisting(existingDefaultSchema)) !== false;
     if (keep) {
-      return { schemaId: existingDefaultSchema, reason: "existing-default-kept" };
+      return { schemaId: existingDefaultSchema, reason: 'existing-default-kept' };
     }
   }
 
   const selected = await promptSelectSchema(availableSchemaIds, existingDefaultSchema);
   assertKnownSchema(selected, availableSchemaIds);
-  return { schemaId: selected, reason: "interactive-selection" };
+  return { schemaId: selected, reason: 'interactive-selection' };
 }
 
 module.exports = {

package/.next/standalone/scripts/init-schema.test.js

@@ -1,18 +1,18 @@
-const test = require("node:test");
-const assert = require("node:assert/strict");
-const fs = require("fs");
-const os = require("os");
-const path = require("path");
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
 
 const {
   discoverSchemaTemplates,
   resolveInitSchemaSelection,
   readProjectConfig,
   writeProjectConfig,
-} = require("./init-schema");
+} = require('./init-schema');
 
 function withTempDir(fn) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "devflow-init-schema-"));
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'devflow-init-schema-'));
   try {
     return fn(dir);
   } finally {
@@ -22,82 +22,82 @@ function withTempDir(fn) {
 
 function writeSchema(baseDir, id) {
   const schemaDir = path.join(baseDir, id);
-  fs.mkdirSync(path.join(schemaDir, "templates"), { recursive: true });
+  fs.mkdirSync(path.join(schemaDir, 'templates'), { recursive: true });
   fs.writeFileSync(
-    path.join(schemaDir, "schema.yaml"),
+    path.join(schemaDir, 'schema.yaml'),
     `name: ${id}\nversion: 1\nartifacts: []\n`,
-    "utf-8"
+    'utf-8',
   );
 }
 
-test("resolveInitSchemaSelection respects explicit schema", async () => {
+test('resolveInitSchemaSelection respects explicit schema', async () => {
   const result = await resolveInitSchemaSelection({
-    requestedSchema: "backend-api",
-    existingDefaultSchema: "spec-driven",
-    availableSchemaIds: ["spec-driven", "backend-api"],
+    requestedSchema: 'backend-api',
+    existingDefaultSchema: 'spec-driven',
+    availableSchemaIds: ['spec-driven', 'backend-api'],
     interactive: false,
   });
-  assert.equal(result.schemaId, "backend-api");
-  assert.equal(result.reason, "explicit");
+  assert.equal(result.schemaId, 'backend-api');
+  assert.equal(result.reason, 'explicit');
 });
 
-test("resolveInitSchemaSelection keeps existing default in interactive mode", async () => {
+test('resolveInitSchemaSelection keeps existing default in interactive mode', async () => {
   const result = await resolveInitSchemaSelection({
-    existingDefaultSchema: "frontend-product",
-    availableSchemaIds: ["frontend-product", "spec-driven"],
+    existingDefaultSchema: 'frontend-product',
+    availableSchemaIds: ['frontend-product', 'spec-driven'],
     interactive: true,
     confirmKeepExisting: async () => true,
-    promptSelectSchema: async () => "spec-driven",
+    promptSelectSchema: async () => 'spec-driven',
   });
-  assert.equal(result.schemaId, "frontend-product");
-  assert.equal(result.reason, "existing-default-kept");
+  assert.equal(result.schemaId, 'frontend-product');
+  assert.equal(result.reason, 'existing-default-kept');
 });
 
-test("resolveInitSchemaSelection uses fallback in non-interactive mode", async () => {
+test('resolveInitSchemaSelection uses fallback in non-interactive mode', async () => {
   const result = await resolveInitSchemaSelection({
-    availableSchemaIds: ["spec-driven", "backend-api"],
+    availableSchemaIds: ['spec-driven', 'backend-api'],
     interactive: false,
   });
-  assert.equal(result.schemaId, "spec-driven");
-  assert.equal(result.reason, "non-interactive-fallback");
+  assert.equal(result.schemaId, 'spec-driven');
+  assert.equal(result.reason, 'non-interactive-fallback');
 });
 
-test("discoverSchemaTemplates returns bundled and project schemas", () =>
+test('discoverSchemaTemplates returns bundled and project schemas', () =>
   withTempDir((root) => {
-    const projectRoot = path.join(root, "project");
-    const packageRoot = path.join(root, "package");
-    const bundledDir = path.join(packageRoot, "src", "schemas");
-    fs.mkdirSync(path.join(projectRoot, "schemas"), { recursive: true });
+    const projectRoot = path.join(root, 'project');
+    const packageRoot = path.join(root, 'package');
+    const bundledDir = path.join(packageRoot, 'src', 'schemas');
+    fs.mkdirSync(path.join(projectRoot, 'schemas'), { recursive: true });
     fs.mkdirSync(bundledDir, { recursive: true });
 
-    writeSchema(bundledDir, "spec-driven");
-    writeSchema(path.join(projectRoot, "schemas"), "custom-team");
+    writeSchema(bundledDir, 'spec-driven');
+    writeSchema(path.join(projectRoot, 'schemas'), 'custom-team');
 
     const schemas = discoverSchemaTemplates({ projectRoot, packageRoot, bundledDir });
     const ids = schemas.map((s) => s.id);
-    assert.deepEqual(ids, ["custom-team", "spec-driven"]);
+    assert.deepEqual(ids, ['custom-team', 'spec-driven']);
   }));
 
-test("discoverSchemaTemplates fails on duplicate IDs", () =>
+test('discoverSchemaTemplates fails on duplicate IDs', () =>
   withTempDir((root) => {
-    const projectRoot = path.join(root, "project");
-    const packageRoot = path.join(root, "package");
-    const bundledDir = path.join(packageRoot, "src", "schemas");
-    fs.mkdirSync(path.join(projectRoot, "schemas"), { recursive: true });
+    const projectRoot = path.join(root, 'project');
+    const packageRoot = path.join(root, 'package');
+    const bundledDir = path.join(packageRoot, 'src', 'schemas');
+    fs.mkdirSync(path.join(projectRoot, 'schemas'), { recursive: true });
     fs.mkdirSync(bundledDir, { recursive: true });
 
-    writeSchema(bundledDir, "spec-driven");
-    writeSchema(path.join(projectRoot, "schemas"), "spec-driven");
+    writeSchema(bundledDir, 'spec-driven');
+    writeSchema(path.join(projectRoot, 'schemas'), 'spec-driven');
 
     assert.throws(
       () => discoverSchemaTemplates({ projectRoot, packageRoot, bundledDir }),
-      /Schema ID conflict/
+      /Schema ID conflict/,
     );
   }));
 
-test("project config read/write round-trip", () =>
+test('project config read/write round-trip', () =>
   withTempDir((projectRoot) => {
-    writeProjectConfig(projectRoot, { defaultSchemaTemplateId: "devops-platform" });
+    writeProjectConfig(projectRoot, { defaultSchemaTemplateId: 'devops-platform' });
     const cfg = readProjectConfig(projectRoot);
-    assert.equal(cfg.defaultSchemaTemplateId, "devops-platform");
+    assert.equal(cfg.defaultSchemaTemplateId, 'devops-platform');
   }));

package/.next/standalone/scripts/install-environments.js

@@ -17,7 +17,14 @@ function parseTools(value) {
   const raw = (value ?? 'all').trim().toLowerCase();
   if (raw === 'none') return [];
   if (raw === 'all') return [...SUPPORTED_TOOLS];
-  return [...new Set(raw.split(',').map(p => normalizeToolId(p.trim())).filter(Boolean))];
+  return [
+    ...new Set(
+      raw
+        .split(',')
+        .map((p) => normalizeToolId(p.trim()))
+        .filter(Boolean),
+    ),
+  ];
 }
 
 function defaultCommandExists(command) {
@@ -36,7 +43,7 @@ function buildDetectionContext(projectRoot, overrides = {}) {
 }
 
 function createDetectedEnvironment(id, signals) {
-  const detected = signals.some(signal => signal.present);
+  const detected = signals.some((signal) => signal.present);
   return { id, detected, signals };
 }
 
@@ -46,7 +53,11 @@ function detectCodex(context) {
     : path.join(context.homedir, '.codex');
   return createDetectedEnvironment('codex', [
     { kind: 'binary', name: 'codex', present: context.commandExists('codex') },
-    { kind: 'directory', name: path.join(context.projectRoot, '.codex'), present: context.pathExists(path.join(context.projectRoot, '.codex')) },
+    {
+      kind: 'directory',
+      name: path.join(context.projectRoot, '.codex'),
+      present: context.pathExists(path.join(context.projectRoot, '.codex')),
+    },
     { kind: 'directory', name: codexHome, present: context.pathExists(codexHome) },
   ]);
 }
@@ -54,8 +65,16 @@ function detectCodex(context) {
 function detectClaudeCode(context) {
   return createDetectedEnvironment('claudecode', [
     { kind: 'binary', name: 'claude', present: context.commandExists('claude') },
-    { kind: 'directory', name: path.join(context.projectRoot, '.claude'), present: context.pathExists(path.join(context.projectRoot, '.claude')) },
-    { kind: 'directory', name: path.join(context.homedir, '.claude'), present: context.pathExists(path.join(context.homedir, '.claude')) },
+    {
+      kind: 'directory',
+      name: path.join(context.projectRoot, '.claude'),
+      present: context.pathExists(path.join(context.projectRoot, '.claude')),
+    },
+    {
+      kind: 'directory',
+      name: path.join(context.homedir, '.claude'),
+      present: context.pathExists(path.join(context.homedir, '.claude')),
+    },
   ]);
 }
 
@@ -69,13 +88,13 @@ function getEnvironmentDetectors() {
 function detectEnvironments(projectRoot, overrides = {}) {
   const context = buildDetectionContext(projectRoot, overrides);
   const detectors = getEnvironmentDetectors();
-  return SUPPORTED_TOOLS.map(tool => detectors[tool].detect(context));
+  return SUPPORTED_TOOLS.map((tool) => detectors[tool].detect(context));
 }
 
 function detectInstalledTools(projectRoot, overrides = {}) {
   return detectEnvironments(projectRoot, overrides)
-    .filter(result => result.detected)
-    .map(result => result.id);
+    .filter((result) => result.detected)
+    .map((result) => result.id);
 }
 
 function getToolAdapters() {

package/.next/standalone/scripts/install-environments.test.js

@@ -13,7 +13,7 @@ const HOME_DIR = '/home/tester';
 
 function detectionHarness({ commands = [], paths = [] } = {}) {
   const commandSet = new Set(commands);
-  const pathSet = new Set(paths.map(p => path.resolve(p)));
+  const pathSet = new Set(paths.map((p) => path.resolve(p)));
   return {
     commandExists: (command) => commandSet.has(command),
     pathExists: (targetPath) => pathSet.has(path.resolve(targetPath)),
@@ -23,23 +23,32 @@ function detectionHarness({ commands = [], paths = [] } = {}) {
 }
 
 test('detectInstalledTools returns claudecode when only Claude signals are present', () => {
-  const detected = detectInstalledTools(PROJECT_ROOT, detectionHarness({
-    commands: ['claude'],
-  }));
+  const detected = detectInstalledTools(
+    PROJECT_ROOT,
+    detectionHarness({
+      commands: ['claude'],
+    }),
+  );
   assert.deepEqual(detected, ['claudecode']);
 });
 
 test('detectInstalledTools returns codex when only Codex signals are present', () => {
-  const detected = detectInstalledTools(PROJECT_ROOT, detectionHarness({
-    commands: ['codex'],
-  }));
+  const detected = detectInstalledTools(
+    PROJECT_ROOT,
+    detectionHarness({
+      commands: ['codex'],
+    }),
+  );
   assert.deepEqual(detected, ['codex']);
 });
 
 test('detectInstalledTools returns both tools when both signals are present', () => {
-  const detected = detectInstalledTools(PROJECT_ROOT, detectionHarness({
-    commands: ['codex', 'claude'],
-  }));
+  const detected = detectInstalledTools(
+    PROJECT_ROOT,
+    detectionHarness({
+      commands: ['codex', 'claude'],
+    }),
+  );
   assert.deepEqual(detected, ['codex', 'claudecode']);
 });