@sureshdsk/devflow-mcp 3.0.0 → 3.0.1

package/.next/standalone/src/lib/schema.test.ts

@@ -1,38 +1,38 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { listSchemas, loadSchema } from "./schema";
+import { afterEach, describe, expect, test } from 'bun:test';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { listSchemas, loadSchema } from './schema';
 
 const tempDirs: string[] = [];
 
 function makeTempProject(): { root: string; projectDir: string; specsDir: string } {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "devflow-schema-test-"));
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'devflow-schema-test-'));
   tempDirs.push(root);
-  const projectDir = path.join(root, "devflow");
-  const specsDir = path.join(projectDir, "specs");
+  const projectDir = path.join(root, 'devflow');
+  const specsDir = path.join(projectDir, 'specs');
   fs.mkdirSync(specsDir, { recursive: true });
   return { root, projectDir, specsDir };
 }
 
 function writeSchema(projectDir: string, name: string): void {
-  const schemaDir = path.join(projectDir, "schemas", name);
-  fs.mkdirSync(path.join(schemaDir, "templates"), { recursive: true });
+  const schemaDir = path.join(projectDir, 'schemas', name);
+  fs.mkdirSync(path.join(schemaDir, 'templates'), { recursive: true });
   fs.writeFileSync(
-    path.join(schemaDir, "schema.yaml"),
+    path.join(schemaDir, 'schema.yaml'),
     [
       `name: ${name}`,
-      "version: 1",
-      "artifacts:",
-      "  - id: proposal",
-      "    generates: proposal.md",
-      "    description: Proposal",
-      "    template: proposal.md",
-      "    requires: []",
-    ].join("\n"),
-    "utf-8"
+      'version: 1',
+      'artifacts:',
+      '  - id: proposal',
+      '    generates: proposal.md',
+      '    description: Proposal',
+      '    template: proposal.md',
+      '    requires: []',
+    ].join('\n'),
+    'utf-8',
   );
-  fs.writeFileSync(path.join(schemaDir, "templates", "proposal.md"), "# Proposal", "utf-8");
+  fs.writeFileSync(path.join(schemaDir, 'templates', 'proposal.md'), '# Proposal', 'utf-8');
 }
 
 afterEach(() => {
@@ -44,35 +44,35 @@ afterEach(() => {
   }
 });
 
-describe("schema registry", () => {
-  test("includes all bundled built-in schema IDs", async () => {
+describe('schema registry', () => {
+  test('includes all bundled built-in schema IDs', async () => {
     const { specsDir } = makeTempProject();
     const entries = await listSchemas(specsDir);
     const ids = entries.map((entry) => entry.id);
-    expect(ids).toContain("spec-driven");
-    expect(ids).toContain("frontend-product");
-    expect(ids).toContain("backend-api");
-    expect(ids).toContain("data-engineering");
-    expect(ids).toContain("devops-platform");
+    expect(ids).toContain('spec-driven');
+    expect(ids).toContain('frontend-product');
+    expect(ids).toContain('backend-api');
+    expect(ids).toContain('data-engineering');
+    expect(ids).toContain('devops-platform');
   });
 
-  test("loads project-local custom schema when present", async () => {
+  test('loads project-local custom schema when present', async () => {
     const { projectDir, specsDir } = makeTempProject();
-    writeSchema(projectDir, "custom-team");
-    const schema = await loadSchema("custom-team", specsDir);
-    expect(schema.name).toBe("custom-team");
+    writeSchema(projectDir, 'custom-team');
+    const schema = await loadSchema('custom-team', specsDir);
+    expect(schema.name).toBe('custom-team');
   });
 
-  test("throws actionable error for unknown schema", async () => {
+  test('throws actionable error for unknown schema', async () => {
     const { specsDir } = makeTempProject();
-    await expect(loadSchema("missing-schema", specsDir)).rejects.toThrow(
-      'Schema "missing-schema" not found. Available schemas:'
+    await expect(loadSchema('missing-schema', specsDir)).rejects.toThrow(
+      'Schema "missing-schema" not found. Available schemas:',
     );
   });
 
-  test("fails fast on ID conflict between bundled and project schemas", async () => {
+  test('fails fast on ID conflict between bundled and project schemas', async () => {
     const { projectDir, specsDir } = makeTempProject();
-    writeSchema(projectDir, "spec-driven");
+    writeSchema(projectDir, 'spec-driven');
     await expect(listSchemas(specsDir)).rejects.toThrow('Schema ID conflict for "spec-driven"');
   });
 });

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

@@ -1,6 +1,6 @@
-import * as fs from "fs";
-import * as path from "path";
-import * as yaml from "js-yaml";
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'js-yaml';
 
 export interface ArtifactDef {
   id: string;
@@ -23,7 +23,7 @@ export interface Schema {
   };
 }
 
-export type SchemaSource = "bundled" | "project";
+export type SchemaSource = 'bundled' | 'project';
 
 export interface SchemaRegistryEntry {
   id: string;
@@ -39,13 +39,13 @@ export interface ApprovalsFile {
 }
 
 export interface ArtifactApproval {
-  state: "draft" | "approved";
+  state: 'draft' | 'approved';
   approvedAt?: string;
   contentHash?: string;
   approvedBy?: string;
 }
 
-export type ArtifactStatusState = "blocked" | "ready" | "in_review" | "done";
+export type ArtifactStatusState = 'blocked' | 'ready' | 'in_review' | 'done';
 
 export interface ArtifactStatus {
   id: string;
@@ -58,10 +58,10 @@ export interface ArtifactStatus {
   approvedBy?: string;
 }
 
-const BUNDLED_SCHEMAS_DIR = path.join(process.cwd(), "src", "schemas");
+const BUNDLED_SCHEMAS_DIR = path.join(process.cwd(), 'src', 'schemas');
 
 function parseSchemaFile(schemaPath: string): Schema {
-  const content = fs.readFileSync(schemaPath, "utf-8");
+  const content = fs.readFileSync(schemaPath, 'utf-8');
   return yaml.load(content) as Schema;
 }
 
@@ -74,7 +74,7 @@ function readSchemaEntriesFromDir(baseDir: string, source: SchemaSource): Schema
 
   const entries: SchemaRegistryEntry[] = [];
   for (const dirName of dirs) {
-    const schemaPath = path.join(baseDir, dirName, "schema.yaml");
+    const schemaPath = path.join(baseDir, dirName, 'schema.yaml');
     if (!fs.existsSync(schemaPath)) continue;
     const schema = parseSchemaFile(schemaPath);
     if (!schema?.name) {
@@ -84,7 +84,7 @@ function readSchemaEntriesFromDir(baseDir: string, source: SchemaSource): Schema
       id: schema.name,
       source,
       schemaPath,
-      templatesDir: path.join(path.dirname(schemaPath), "templates"),
+      templatesDir: path.join(path.dirname(schemaPath), 'templates'),
       schema,
     });
   }
@@ -92,16 +92,16 @@ function readSchemaEntriesFromDir(baseDir: string, source: SchemaSource): Schema
 }
 
 export async function listSchemas(specsDir: string): Promise<SchemaRegistryEntry[]> {
-  const projectSchemasDir = path.join(path.dirname(specsDir), "schemas");
-  const bundledEntries = readSchemaEntriesFromDir(BUNDLED_SCHEMAS_DIR, "bundled");
-  const projectEntries = readSchemaEntriesFromDir(projectSchemasDir, "project");
+  const projectSchemasDir = path.join(path.dirname(specsDir), 'schemas');
+  const bundledEntries = readSchemaEntriesFromDir(BUNDLED_SCHEMAS_DIR, 'bundled');
+  const projectEntries = readSchemaEntriesFromDir(projectSchemasDir, 'project');
 
   const idToEntry = new Map<string, SchemaRegistryEntry>();
   for (const entry of [...bundledEntries, ...projectEntries]) {
     const existing = idToEntry.get(entry.id);
     if (existing) {
       throw new Error(
-        `Schema ID conflict for "${entry.id}" between ${existing.source}:${existing.schemaPath} and ${entry.source}:${entry.schemaPath}`
+        `Schema ID conflict for "${entry.id}" between ${existing.source}:${existing.schemaPath} and ${entry.source}:${entry.schemaPath}`,
       );
     }
     idToEntry.set(entry.id, entry);
@@ -114,11 +114,11 @@ export async function loadSchema(schemaName: string, specsDir: string): Promise<
   const entries = await listSchemas(specsDir);
   const entry = entries.find((schema) => schema.id === schemaName);
   if (!entry) {
-    const available = entries.map((schema) => schema.id).join(", ");
+    const available = entries.map((schema) => schema.id).join(', ');
     throw new Error(
       available.length > 0
         ? `Schema "${schemaName}" not found. Available schemas: ${available}`
-        : `Schema "${schemaName}" not found`
+        : `Schema "${schemaName}" not found`,
     );
   }
 
@@ -128,7 +128,7 @@ export async function loadSchema(schemaName: string, specsDir: string): Promise<
 export async function resolveTemplate(
   schema: Schema,
   artifactId: string,
-  specsDir: string
+  specsDir: string,
 ): Promise<string> {
   const artifact = schema.artifacts.find((a) => a.id === artifactId);
   if (!artifact) throw new Error(`Artifact "${artifactId}" not found in schema`);
@@ -136,29 +136,75 @@ export async function resolveTemplate(
   // 1. Try project-local template
   const localTemplatePath = path.join(
     path.dirname(specsDir),
-    "schemas",
+    'schemas',
     schema.name,
-    "templates",
-    artifact.template
+    'templates',
+    artifact.template,
   );
   if (fs.existsSync(localTemplatePath)) {
-    return fs.readFileSync(localTemplatePath, "utf-8");
+    return fs.readFileSync(localTemplatePath, 'utf-8');
   }
 
   // 2. Try bundled template
   const bundledTemplatePath = path.join(
     BUNDLED_SCHEMAS_DIR,
     schema.name,
-    "templates",
-    artifact.template
+    'templates',
+    artifact.template,
   );
   if (fs.existsSync(bundledTemplatePath)) {
-    return fs.readFileSync(bundledTemplatePath, "utf-8");
+    return fs.readFileSync(bundledTemplatePath, 'utf-8');
   }
 
   return `# ${artifactId}\n\n<!-- Write your ${artifactId} here -->\n`;
 }
 
+export interface CreateSchemaInput {
+  name: string;
+  artifacts: ArtifactDef[];
+  qualityRules?: Schema['qualityRules'];
+  apply?: Schema['apply'];
+  templates: Record<string, string>;
+}
+
+export async function createSchema(input: CreateSchemaInput, specsDir: string): Promise<string> {
+  const { name, artifacts, qualityRules, apply, templates } = input;
+
+  // Validate no name conflict
+  const existing = await listSchemas(specsDir);
+  const conflict = existing.find((e) => e.id === name);
+  if (conflict) {
+    throw new Error(`Schema "${name}" already exists (${conflict.source}: ${conflict.schemaPath})`);
+  }
+
+  const projectSchemasDir = path.join(path.dirname(specsDir), 'schemas', name);
+  const templatesDir = path.join(projectSchemasDir, 'templates');
+
+  fs.mkdirSync(templatesDir, { recursive: true });
+
+  // Build schema object
+  const schemaObj: Schema = {
+    name,
+    version: 1,
+    artifacts,
+    ...(qualityRules && { qualityRules }),
+    ...(apply && { apply }),
+  };
+
+  // Write schema.yaml
+  const schemaYaml = yaml.dump(schemaObj, { lineWidth: 120, noRefs: true });
+  fs.writeFileSync(path.join(projectSchemasDir, 'schema.yaml'), schemaYaml, 'utf-8');
+
+  // Write template files
+  for (const artifact of artifacts) {
+    const templateContent =
+      templates[artifact.id] || `# ${artifact.id}\n\n<!-- Write your ${artifact.id} here -->\n`;
+    fs.writeFileSync(path.join(templatesDir, artifact.template), templateContent, 'utf-8');
+  }
+
+  return projectSchemasDir;
+}
+
 export function getArtifactBlockers(schema: Schema): Record<string, string[]> {
   const blockers: Record<string, string[]> = {};
   for (const artifact of schema.artifacts) {
@@ -170,28 +216,28 @@ export function getArtifactBlockers(schema: Schema): Record<string, string[]> {
 export function computeSpecStatus(
   schema: Schema,
   approvals: ApprovalsFile,
-  artifactFiles: Record<string, boolean>
+  artifactFiles: Record<string, boolean>,
 ): ArtifactStatus[] {
   return schema.artifacts.map((artifact) => {
     const approval = approvals.artifacts[artifact.id];
     const fileExists = artifactFiles[artifact.id] || false;
-    const isApproved = approval?.state === "approved";
+    const isApproved = approval?.state === 'approved';
 
     // Check if all required predecessors are approved
     const allRequiredApproved = artifact.requires.every((req) => {
       const reqApproval = approvals.artifacts[req];
-      return reqApproval?.state === "approved";
+      return reqApproval?.state === 'approved';
     });
 
     let state: ArtifactStatusState;
     if (!allRequiredApproved && artifact.requires.length > 0) {
-      state = "blocked";
+      state = 'blocked';
     } else if (!fileExists) {
-      state = "ready";
+      state = 'ready';
     } else if (!isApproved) {
-      state = "in_review";
+      state = 'in_review';
     } else {
-      state = "done";
+      state = 'done';
     }
 
     return {

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

@@ -1,16 +1,16 @@
-import * as fs from "fs";
-import * as path from "path";
-import * as yaml from "js-yaml";
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'js-yaml';
 
 interface DevflowConfig {
   specsDir?: string;
 }
 
 function loadConfig(): DevflowConfig {
-  const configPath = path.join(process.cwd(), "devflow.yaml");
+  const configPath = path.join(process.cwd(), 'devflow.yaml');
   if (fs.existsSync(configPath)) {
     try {
-      const content = fs.readFileSync(configPath, "utf-8");
+      const content = fs.readFileSync(configPath, 'utf-8');
       return (yaml.load(content) as DevflowConfig) || {};
     } catch {
       return {};
@@ -24,7 +24,7 @@ export function getSpecsDir(): string {
   if (config.specsDir) {
     return path.resolve(process.cwd(), config.specsDir);
   }
-  return path.join(process.cwd(), "devflow", "specs");
+  return path.join(process.cwd(), 'devflow', 'specs');
 }
 
 export function getSpecDir(specName: string): string {
@@ -32,11 +32,11 @@ export function getSpecDir(specName: string): string {
 }
 
 export function getApprovalsPath(specName: string): string {
-  return path.join(getSpecDir(specName), ".approvals.json");
+  return path.join(getSpecDir(specName), '.approvals.json');
 }
 
 export function getMetaPath(specName: string): string {
-  return path.join(getSpecDir(specName), ".meta.json");
+  return path.join(getSpecDir(specName), '.meta.json');
 }
 
 export function getArtifactPath(specName: string, artifactType: string): string {