@sureshdsk/devflow-mcp 3.0.0 → 3.0.1

package/.next/standalone/src/lib/specs.ts

@@ -1,13 +1,13 @@
-import * as fs from "fs";
-import * as path from "path";
-import { createHash } from "crypto";
+import * as fs from 'fs';
+import * as path from 'path';
+import { createHash } from 'crypto';
 import {
   getSpecsDir,
   getSpecDir,
   getApprovalsPath,
   getMetaPath,
   getArtifactPath,
-} from "./specs-dir";
+} from './specs-dir';
 import {
   loadSchema,
   computeSpecStatus,
@@ -15,8 +15,8 @@ import {
   type ApprovalsFile,
   type ArtifactStatus,
   type Schema,
-} from "./schema";
-import { getDb, schema as dbSchema } from "../db/index";
+} from './schema';
+import { getDb, schema as dbSchema } from '../db/index';
 
 export interface SpecMeta {
   name: string;
@@ -41,7 +41,7 @@ export interface ParsedTask {
 
 export interface ValidationFinding {
   code: string;
-  severity: "error" | "warning";
+  severity: 'error' | 'warning';
   message: string;
 }
 
@@ -51,19 +51,19 @@ export interface ValidationReport {
 }
 
 function defaultApprovals(schema: Schema): ApprovalsFile {
-  const artifacts: Record<string, { state: "draft" }> = {};
+  const artifacts: Record<string, { state: 'draft' }> = {};
   for (const artifact of schema.artifacts) {
-    artifacts[artifact.id] = { state: "draft" };
+    artifacts[artifact.id] = { state: 'draft' };
   }
   return { version: 1, artifacts };
 }
 
 async function getSchema(specName: string): Promise<Schema> {
   const metaPath = getMetaPath(specName);
-  let schemaName = "spec-driven";
+  let schemaName = 'spec-driven';
   if (fs.existsSync(metaPath)) {
-    const meta = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
-    schemaName = meta.schema || "spec-driven";
+    const meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+    schemaName = meta.schema || 'spec-driven';
   }
   return loadSchema(schemaName, getSpecsDir());
 }
@@ -76,10 +76,10 @@ export async function listSpecs(): Promise<SpecMeta[]> {
   const specs: SpecMeta[] = [];
 
   for (const entry of entries) {
-    if (!entry.isDirectory() || entry.name === "archive") continue;
-    const metaPath = path.join(specsDir, entry.name, ".meta.json");
+    if (!entry.isDirectory() || entry.name === 'archive') continue;
+    const metaPath = path.join(specsDir, entry.name, '.meta.json');
     if (fs.existsSync(metaPath)) {
-      const meta = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
+      const meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
       specs.push({ name: entry.name, ...meta });
     }
   }
@@ -93,8 +93,8 @@ export async function getSpec(specName: string): Promise<SpecDetail> {
     throw new Error(`Spec "${specName}" not found`);
   }
 
-  const meta = JSON.parse(fs.readFileSync(metaPath, "utf-8")) as SpecMeta;
-  const schema = await loadSchema(meta.schema || "spec-driven", getSpecsDir());
+  const meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8')) as SpecMeta;
+  const schema = await loadSchema(meta.schema || 'spec-driven', getSpecsDir());
   const approvals = await getApprovals(specName);
 
   const artifacts: Record<string, string | null> = {};
@@ -103,7 +103,7 @@ export async function getSpec(specName: string): Promise<SpecDetail> {
   for (const artifact of schema.artifacts) {
     const artifactPath = getArtifactPath(specName, artifact.id);
     if (fs.existsSync(artifactPath)) {
-      artifacts[artifact.id] = fs.readFileSync(artifactPath, "utf-8");
+      artifacts[artifact.id] = fs.readFileSync(artifactPath, 'utf-8');
       artifactFiles[artifact.id] = true;
     } else {
       artifacts[artifact.id] = null;
@@ -125,13 +125,13 @@ export async function getSpec(specName: string): Promise<SpecDetail> {
 export async function getArtifact(specName: string, artifactType: string): Promise<string | null> {
   const artifactPath = getArtifactPath(specName, artifactType);
   if (!fs.existsSync(artifactPath)) return null;
-  return fs.readFileSync(artifactPath, "utf-8");
+  return fs.readFileSync(artifactPath, 'utf-8');
 }
 
 export async function writeArtifact(
   specName: string,
   artifactType: string,
-  content: string
+  content: string,
 ): Promise<void> {
   const specDir = getSpecDir(specName);
   if (!fs.existsSync(specDir)) {
@@ -139,14 +139,29 @@ export async function writeArtifact(
   }
 
   const artifactPath = getArtifactPath(specName, artifactType);
-  fs.writeFileSync(artifactPath, content, "utf-8");
+  fs.writeFileSync(artifactPath, content, 'utf-8');
 
   // Auto-invalidate: if was approved, reset to draft
+  // But skip reset for "tasks" if tasks have already been promoted to Kanban
   const approvals = await getApprovals(specName);
   const existing = approvals.artifacts[artifactType];
-  if (existing?.state === "approved") {
-    approvals.artifacts[artifactType] = { state: "draft" };
-    await writeApprovals(specName, approvals);
+  if (existing?.state === 'approved') {
+    let skipReset = false;
+    if (artifactType === 'tasks') {
+      const { getDb, schema: dbSchema } = await import('@/db');
+      const { eq } = await import('drizzle-orm');
+      const db = await getDb();
+      const promoted = await db
+        .select({ id: dbSchema.tasks.id })
+        .from(dbSchema.tasks)
+        .where(eq(dbSchema.tasks.specName, specName))
+        .limit(1);
+      skipReset = promoted.length > 0;
+    }
+    if (!skipReset) {
+      approvals.artifacts[artifactType] = { state: 'draft' };
+      await writeApprovals(specName, approvals);
+    }
   }
 }
 
@@ -156,18 +171,18 @@ export async function getApprovals(specName: string): Promise<ApprovalsFile> {
     const schema = await getSchema(specName);
     return defaultApprovals(schema);
   }
-  return JSON.parse(fs.readFileSync(approvalsPath, "utf-8")) as ApprovalsFile;
+  return JSON.parse(fs.readFileSync(approvalsPath, 'utf-8')) as ApprovalsFile;
 }
 
 export async function writeApprovals(specName: string, approvals: ApprovalsFile): Promise<void> {
   const approvalsPath = getApprovalsPath(specName);
-  fs.writeFileSync(approvalsPath, JSON.stringify(approvals, null, 2), "utf-8");
+  fs.writeFileSync(approvalsPath, JSON.stringify(approvals, null, 2), 'utf-8');
 }
 
 export async function approveArtifact(
   specName: string,
   artifactType: string,
-  approvedBy: string
+  approvedBy: string,
 ): Promise<void> {
   const schema = await getSchema(specName);
   const artifactDef = schema.artifacts.find((a) => a.id === artifactType);
@@ -178,7 +193,7 @@ export async function approveArtifact(
   // Check blockers
   for (const req of artifactDef.requires) {
     const reqApproval = approvals.artifacts[req];
-    if (!reqApproval || reqApproval.state !== "approved") {
+    if (!reqApproval || reqApproval.state !== 'approved') {
       throw new Error(`Cannot approve "${artifactType}": "${req}" must be approved first`);
     }
   }
@@ -188,9 +203,9 @@ export async function approveArtifact(
     throw new Error(`Cannot approve "${artifactType}": file does not exist`);
   }
 
-  const contentHash = createHash("sha256").update(content).digest("hex");
+  const contentHash = createHash('sha256').update(content).digest('hex');
   approvals.artifacts[artifactType] = {
-    state: "approved",
+    state: 'approved',
     approvedAt: new Date().toISOString(),
     contentHash,
     approvedBy,
@@ -201,7 +216,7 @@ export async function approveArtifact(
 
 export async function draftArtifact(specName: string, artifactType: string): Promise<void> {
   const approvals = await getApprovals(specName);
-  approvals.artifacts[artifactType] = { state: "draft" };
+  approvals.artifacts[artifactType] = { state: 'draft' };
   await writeApprovals(specName, approvals);
 }
 
@@ -219,9 +234,9 @@ export async function getSpecStatus(specName: string): Promise<ArtifactStatus[]>
 }
 
 const PRIORITY_MAP: Record<string, string> = {
-  p0: "high",
-  p1: "medium",
-  p2: "low",
+  p0: 'high',
+  p1: 'medium',
+  p2: 'low',
 };
 
 function normalizePriority(raw: string): string {
@@ -230,13 +245,13 @@ function normalizePriority(raw: string): string {
 }
 
 export async function parseTasksArtifact(specName: string): Promise<ParsedTask[]> {
-  const content = await getArtifact(specName, "tasks");
+  const content = await getArtifact(specName, 'tasks');
   if (!content) return [];
 
   const taskHeaderRegex = /^#{2,4}\s+\d*\.?\d*\s*Task:\s*(.+)/m;
-  const blocks = content.split(/(?=^#{2,4}\s+\d*\.?\d*\s*Task:\s*)/m).filter((b) =>
-    taskHeaderRegex.test(b)
-  );
+  const blocks = content
+    .split(/(?=^#{2,4}\s+\d*\.?\d*\s*Task:\s*)/m)
+    .filter((b) => taskHeaderRegex.test(b));
 
   const tasks: ParsedTask[] = [];
 
@@ -247,7 +262,7 @@ export async function parseTasksArtifact(specName: string): Promise<ParsedTask[]
     const title = headerMatch[1].trim();
 
     // Extract priority from **Priority:** metadata line
-    let priority = "medium";
+    let priority = 'medium';
     const priorityMatch = block.match(/^\*\*Priority:\*\*\s*(.+)$/m);
     if (priorityMatch) {
       priority = normalizePriority(priorityMatch[1]);
@@ -272,38 +287,29 @@ export function fillTaskSummary(
     filesChanged?: string;
     issuesEncountered?: string;
     followUps?: string;
-  }
+  },
 ): string {
   let result = body;
 
   // Replace the entire Task Summary section lines with filled values.
   // Handles both "- Key: <!-- placeholder -->" and bare "<!-- placeholder -->" patterns.
-  result = result.replace(
-    /^(- Completed:)\s*<!--.*?-->/gim,
-    `$1 yes`
-  );
-  result = result.replace(
-    /^(- What was done:)\s*<!--.*?-->/gim,
-    `$1 ${summary.whatWasDone}`
-  );
+  result = result.replace(/^(- Completed:)\s*<!--.*?-->/gim, `$1 yes`);
+  result = result.replace(/^(- What was done:)\s*<!--.*?-->/gim, `$1 ${summary.whatWasDone}`);
   result = result.replace(
     /^(- Files changed:)\s*<!--.*?-->/gim,
-    `$1 ${summary.filesChanged ?? "N/A"}`
+    `$1 ${summary.filesChanged ?? 'N/A'}`,
   );
   result = result.replace(
     /^(- Issues encountered:)\s*<!--.*?-->/gim,
-    `$1 ${summary.issuesEncountered ?? "None"}`
-  );
-  result = result.replace(
-    /^(- Follow-ups:)\s*<!--.*?-->/gim,
-    `$1 ${summary.followUps ?? "None"}`
+    `$1 ${summary.issuesEncountered ?? 'None'}`,
   );
+  result = result.replace(/^(- Follow-ups:)\s*<!--.*?-->/gim, `$1 ${summary.followUps ?? 'None'}`);
 
   // Fallback: bare <!-- what was done --> style comments (legacy)
   result = result.replace(/<!--\s*what was done\s*-->/gi, summary.whatWasDone);
-  result = result.replace(/<!--\s*files changed\s*-->/gi, summary.filesChanged ?? "N/A");
-  result = result.replace(/<!--\s*issues encountered\s*-->/gi, summary.issuesEncountered ?? "None");
-  result = result.replace(/<!--\s*follow.?ups?\s*-->/gi, summary.followUps ?? "None");
+  result = result.replace(/<!--\s*files changed\s*-->/gi, summary.filesChanged ?? 'N/A');
+  result = result.replace(/<!--\s*issues encountered\s*-->/gi, summary.issuesEncountered ?? 'None');
+  result = result.replace(/<!--\s*follow.?ups?\s*-->/gi, summary.followUps ?? 'None');
 
   return result;
 }
@@ -311,13 +317,13 @@ export function fillTaskSummary(
 export async function updateTaskBodyInSpec(
   specName: string,
   taskTitle: string,
-  newBody: string
+  newBody: string,
 ): Promise<void> {
   try {
-    const artifactPath = getArtifactPath(specName, "tasks");
+    const artifactPath = getArtifactPath(specName, 'tasks');
     if (!fs.existsSync(artifactPath)) return;
 
-    const content = fs.readFileSync(artifactPath, "utf-8");
+    const content = fs.readFileSync(artifactPath, 'utf-8');
     const taskHeaderRegex = /^#{2,4}\s+\d*\.?\d*\s*Task:\s*(.+)/m;
 
     // Split into blocks
@@ -328,21 +334,21 @@ export async function updateTaskBodyInSpec(
       const match = part.match(taskHeaderRegex);
       if (match && match[1].trim() === taskTitle) {
         replaced = true;
-        return newBody + (part.endsWith("\n") ? "\n" : "");
+        return newBody + (part.endsWith('\n') ? '\n' : '');
       }
       return part;
     });
 
     if (!replaced) return;
 
-    const newContent = newParts.join("");
-    fs.writeFileSync(artifactPath, newContent, "utf-8");
+    const newContent = newParts.join('');
+    fs.writeFileSync(artifactPath, newContent, 'utf-8');
 
     // Reset approval to draft
     const approvals = await getApprovals(specName);
-    const existing = approvals.artifacts["tasks"];
-    if (existing?.state === "approved") {
-      approvals.artifacts["tasks"] = { state: "draft" };
+    const existing = approvals.artifacts['tasks'];
+    if (existing?.state === 'approved') {
+      approvals.artifacts['tasks'] = { state: 'draft' };
       await writeApprovals(specName, approvals);
     }
   } catch {
@@ -355,7 +361,7 @@ export async function createSpec(
   title: string,
   projectId: string,
   description?: string,
-  schemaName = "spec-driven"
+  schemaName = 'spec-driven',
 ): Promise<void> {
   const specDir = getSpecDir(specName);
   if (fs.existsSync(specDir)) {
@@ -373,7 +379,7 @@ export async function createSpec(
     createdAt: new Date().toISOString(),
   };
 
-  fs.writeFileSync(getMetaPath(specName), JSON.stringify(meta, null, 2), "utf-8");
+  fs.writeFileSync(getMetaPath(specName), JSON.stringify(meta, null, 2), 'utf-8');
 
   const artifactSchema = await loadSchema(schemaName, getSpecsDir());
   await writeApprovals(specName, defaultApprovals(artifactSchema));
@@ -386,7 +392,7 @@ export async function createSpec(
     title,
     description: description ?? null,
     schema: schemaName,
-    status: "active",
+    status: 'active',
     createdAt: new Date(),
   });
 }
@@ -400,52 +406,52 @@ export async function validateSpec(specName: string): Promise<ValidationReport>
     const content = await getArtifact(specName, artifact.id);
     if (!content) {
       findings.push({
-        code: "ARTIFACT_MISSING",
-        severity: "error",
+        code: 'ARTIFACT_MISSING',
+        severity: 'error',
         message: `Artifact "${artifact.id}" has not been created yet`,
       });
       continue;
     }
 
     const approval = approvals.artifacts[artifact.id];
-    if (!approval || approval.state !== "approved") {
+    if (!approval || approval.state !== 'approved') {
       findings.push({
-        code: "ARTIFACT_NOT_APPROVED",
-        severity: "error",
+        code: 'ARTIFACT_NOT_APPROVED',
+        severity: 'error',
         message: `Artifact "${artifact.id}" exists but has not been approved`,
       });
     }
 
-    if (artifact.id === "tasks") {
+    if (artifact.id === 'tasks') {
       const parsedTasks = await parseTasksArtifact(specName);
       if (parsedTasks.length === 0) {
         findings.push({
-          code: "TASKS_EMPTY",
-          severity: "error",
+          code: 'TASKS_EMPTY',
+          severity: 'error',
           message: 'tasks.md has no parseable "## Task:" entries',
         });
       }
     }
 
-    if (artifact.id === "specs" && content) {
-      if (!content.includes("### Requirement:")) {
+    if (artifact.id === 'specs' && content) {
+      if (!content.includes('### Requirement:')) {
         findings.push({
-          code: "SPEC_NO_REQUIREMENTS",
-          severity: "warning",
+          code: 'SPEC_NO_REQUIREMENTS',
+          severity: 'warning',
           message: 'specs.md has no "### Requirement:" headings',
         });
       }
-      if (!content.includes("#### Scenario:")) {
+      if (!content.includes('#### Scenario:')) {
         findings.push({
-          code: "SPEC_NO_SCENARIOS",
-          severity: "warning",
+          code: 'SPEC_NO_SCENARIOS',
+          severity: 'warning',
           message: 'specs.md has no "#### Scenario:" headings',
         });
       }
     }
   }
 
-  return { ok: findings.filter((f) => f.severity === "error").length === 0, findings };
+  return { ok: findings.filter((f) => f.severity === 'error').length === 0, findings };
 }
 
 export async function archiveSpec(specName: string): Promise<void> {
@@ -454,7 +460,7 @@ export async function archiveSpec(specName: string): Promise<void> {
     throw new Error(`Spec "${specName}" not found`);
   }
 
-  const archiveDir = path.join(getSpecsDir(), "archive");
+  const archiveDir = path.join(getSpecsDir(), 'archive');
   fs.mkdirSync(archiveDir, { recursive: true });
 
   const archiveDest = path.join(archiveDir, specName);
@@ -462,14 +468,14 @@ export async function archiveSpec(specName: string): Promise<void> {
 
   // Update DB status
   const db = await getDb();
-  const { eq } = await import("drizzle-orm");
-  await db.update(dbSchema.specs).set({ status: "archived" }).where(eq(dbSchema.specs.name, specName));
+  const { eq } = await import('drizzle-orm');
+  await db
+    .update(dbSchema.specs)
+    .set({ status: 'archived' })
+    .where(eq(dbSchema.specs.name, specName));
 }
 
-export async function getArtifactTemplate(
-  specName: string,
-  artifactId: string
-): Promise<string> {
+export async function getArtifactTemplate(specName: string, artifactId: string): Promise<string> {
   const schema = await getSchema(specName);
   return resolveTemplate(schema, artifactId, getSpecsDir());
 }

package/.next/standalone/src/lib/utils.ts

@@ -1,5 +1,5 @@
-import { type ClassValue, clsx } from "clsx";
-import { twMerge } from "tailwind-merge";
+import { type ClassValue, clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
 
 export function cn(...inputs: ClassValue[]) {
   return twMerge(clsx(inputs));