agent-enderun 0.5.8 → 0.6.0

package/framework-mcp/dist/tools/scaffold.js

@@ -0,0 +1,129 @@
+import fs from "fs";
+import path from "path";
+import { resolveSafePath, getFrameworkDir } from "../utils.js";
+import { INSTANTIATE_BLUEPRINT_ARGS_SCHEMA, LIST_BLUEPRINTS_ARGS_SCHEMA, SAVE_AS_BLUEPRINT_ARGS_SCHEMA } from "../schemas.js";
+export const scaffoldTools = [
+    {
+        name: "instantiate_blueprint",
+        description: "Clones a Gold Standard capability from .enderun/blueprints into the application source.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                blueprintPath: { type: "string", description: "Relative path within blueprints/ (e.g., backend/errors)" },
+                targetPath: { type: "string", description: "Target directory in the app (e.g., apps/backend/src/errors)" },
+            },
+            required: ["blueprintPath", "targetPath"],
+        },
+    },
+    {
+        name: "save_as_blueprint",
+        description: "Saves or updates a high-quality code pattern as a Gold Standard blueprint for reuse.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                blueprintPath: { type: "string", description: "Target relative path in blueprints/ (e.g., frontend/ui/Button.tsx)" },
+                content: { type: "string", description: "The full source code of the blueprint" },
+                description: { type: "string", description: "Brief description of what this blueprint provides" },
+            },
+            required: ["blueprintPath", "content"],
+        },
+    },
+    {
+        name: "list_blueprints",
+        description: "Lists all available Gold Standard blueprints in the framework.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                category: { type: "string", enum: ["backend", "frontend"], description: "Optional category to filter blueprints" },
+            },
+        },
+    },
+];
+export const scaffoldHandlers = {
+    instantiate_blueprint: async (args, projectRoot) => {
+        const parsed = INSTANTIATE_BLUEPRINT_ARGS_SCHEMA.safeParse(args);
+        if (!parsed.success)
+            return { content: [{ type: "text", text: `Invalid arguments: ${parsed.error.message}` }] };
+        const { blueprintPath, targetPath } = parsed.data;
+        const frameworkDir = getFrameworkDir(projectRoot);
+        const sourceDir = resolveSafePath(projectRoot, path.join(frameworkDir, "blueprints", blueprintPath));
+        const destDir = resolveSafePath(projectRoot, targetPath);
+        try {
+            if (!fs.existsSync(sourceDir)) {
+                return { content: [{ type: "text", text: `Blueprint not found: ${blueprintPath}` }] };
+            }
+            // Create target directory if it doesn't exist
+            fs.mkdirSync(path.dirname(destDir), { recursive: true });
+            // Copy recursively
+            // Using cpSync which is available in Node.js 16.7.0+
+            fs.cpSync(sourceDir, destDir, { recursive: true });
+            return { content: [{ type: "text", text: `Successfully instantiated blueprint '${blueprintPath}' into '${targetPath}'` }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Scaffold failed: ${error.message}` }] };
+        }
+    },
+    save_as_blueprint: async (args, projectRoot) => {
+        const parsed = SAVE_AS_BLUEPRINT_ARGS_SCHEMA.safeParse(args);
+        if (!parsed.success)
+            return { content: [{ type: "text", text: `Invalid arguments: ${parsed.error.message}` }] };
+        const { blueprintPath, content, description } = parsed.data;
+        const frameworkDir = getFrameworkDir(projectRoot);
+        const targetFile = resolveSafePath(projectRoot, path.join(frameworkDir, "blueprints", blueprintPath));
+        try {
+            // Ensure the blueprints subdirectory exists
+            fs.mkdirSync(path.dirname(targetFile), { recursive: true });
+            // Write the blueprint content
+            fs.writeFileSync(targetFile, content, "utf-8");
+            // Optionally write a .metadata file if description provided
+            if (description) {
+                const metaFile = `${targetFile}.metadata.json`;
+                fs.writeFileSync(metaFile, JSON.stringify({ description, savedAt: new Date().toISOString() }, null, 2), "utf-8");
+            }
+            return { content: [{ type: "text", text: `Successfully saved blueprint to '${blueprintPath}'` }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Failed to save blueprint: ${error.message}` }] };
+        }
+    },
+    list_blueprints: async (args, projectRoot) => {
+        const parsed = LIST_BLUEPRINTS_ARGS_SCHEMA.safeParse(args ?? {});
+        const category = parsed.success ? parsed.data.category : undefined;
+        const frameworkDir = getFrameworkDir(projectRoot);
+        const blueprintsRoot = path.join(projectRoot, frameworkDir, "blueprints");
+        try {
+            if (!fs.existsSync(blueprintsRoot)) {
+                return { content: [{ type: "text", text: "Blueprints directory not found." }] };
+            }
+            const walk = (dir) => {
+                const results = [];
+                if (!fs.existsSync(dir))
+                    return results;
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const res = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        // If it's a leaf directory containing files, or we want to show all dirs
+                        const subEntries = fs.readdirSync(res);
+                        const hasFiles = subEntries.some(e => !fs.lstatSync(path.join(res, e)).isDirectory());
+                        if (hasFiles) {
+                            results.push(path.relative(blueprintsRoot, res));
+                        }
+                        results.push(...walk(res));
+                    }
+                }
+                return results;
+            };
+            let available = walk(blueprintsRoot);
+            if (category) {
+                available = available.filter(b => b.startsWith(category));
+            }
+            // Remove duplicates
+            available = Array.from(new Set(available));
+            return { content: [{ type: "text", text: `### AVAILABLE BLUEPRINTS\n\n` + available.map(b => `- ${b}`).join("\n") }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Listing blueprints failed: ${error.message}` }] };
+        }
+    },
+};

package/{packages/framework-mcp → framework-mcp}/dist/utils.js

@@ -1,6 +1,6 @@
 import path from "path";
 import fs from "fs";
-export const FRAMEWORK_VERSION = "0.5.8";
+export const FRAMEWORK_VERSION = "0.6.0";
 export function getFrameworkDir(projectRoot) {
     const adapters = [".gemini", ".claude", ".cursor", ".enderun", ".codex"];
     for (const adp of adapters) {

package/{packages/framework-mcp → framework-mcp}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-enderun-mcp",
-  "version": "0.5.8",
+  "version": "0.6.0",
   "description": "Enterprise-grade MCP Server for AI Agent Framework",
   "author": "Yusuf BEKAR",
   "license": "MIT",
@@ -25,6 +25,9 @@
     "dist",
     "README.md"
   ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "start": "node dist/index.js",

package/{packages/framework-mcp → framework-mcp}/src/schemas.ts

@@ -124,3 +124,18 @@ export const SYNC_CONTRACT_HASH_ARGS_SCHEMA = z.object({
 export const VERIFY_FRAMEWORK_HEALTH_ARGS_SCHEMA = z.object({
     detailed: z.boolean().default(false),
 });
+
+export const INSTANTIATE_BLUEPRINT_ARGS_SCHEMA = z.object({
+    blueprintPath: z.string().min(1),
+    targetPath: z.string().min(1),
+});
+
+export const LIST_BLUEPRINTS_ARGS_SCHEMA = z.object({
+    category: z.enum(["backend", "frontend"]).optional(),
+});
+
+export const SAVE_AS_BLUEPRINT_ARGS_SCHEMA = z.object({
+    blueprintPath: z.string().min(1),
+    content: z.string().min(1),
+    description: z.string().optional(),
+});

package/{packages/framework-mcp → framework-mcp}/src/tools/contract.ts

@@ -50,8 +50,8 @@ export const contractTools = [
 export const contractHandlers = {
     verify_api_contract: async (args: unknown, projectRoot: string) => {
         try {
-            const sharedTypesDir = path.join(projectRoot, "packages/shared-types/src");
-            const contractJsonPath = path.join(projectRoot, "packages/shared-types/contract.version.json");
+            const sharedTypesDir = path.join(projectRoot, "apps/backend/src/types");
+            const contractJsonPath = path.join(projectRoot, "apps/backend/contract.version.json");
             if (!fs.existsSync(sharedTypesDir) || !fs.existsSync(contractJsonPath)) return { content: [{ type: "text", text: "Missing shared-types directory or contract.version.json" }] };
             const currentHash = calculateContractHash(sharedTypesDir, projectRoot);
             const storedHash = JSON.parse(fs.readFileSync(contractJsonPath, "utf-8")).contract_hash;
@@ -62,8 +62,8 @@ export const contractHandlers = {
     },
     update_contract_hash: async (args: unknown, projectRoot: string) => {
         try {
-            const sharedTypesDir = path.join(projectRoot, "packages/shared-types/src");
-            const contractJsonPath = path.join(projectRoot, "packages/shared-types/contract.version.json");
+            const sharedTypesDir = path.join(projectRoot, "apps/backend/src/types");
+            const contractJsonPath = path.join(projectRoot, "apps/backend/contract.version.json");
             if (!fs.existsSync(sharedTypesDir)) return { content: [{ type: "text", text: "Missing shared-types directory" }] };
             const files = collectFilesRecursively(sharedTypesDir, new Set(["ts"])).sort();
             if (files.length === 0) return { content: [{ type: "text", text: "⚠️ WARNING: No TypeScript files found in shared-types/src. Hash not updated." }] };
@@ -83,13 +83,26 @@ export const contractHandlers = {
         try {
             const frameworkDir = getFrameworkDir(projectRoot);
             const apiDocPath = path.join(projectRoot, frameworkDir, "docs/api", `${parsed.data.domain}.md`);
-            const sharedTypesPath = path.join(projectRoot, "packages/shared-types/src/index.ts");
+            const sharedTypesDir = path.join(projectRoot, "apps/backend/src/types");
+
             if (!fs.existsSync(apiDocPath)) return { content: [{ type: "text", text: `API documentation not found for domain: ${parsed.data.domain}` }] };
-            if (!fs.existsSync(sharedTypesPath)) return { content: [{ type: "text", text: "Shared types index.ts not found." }] };
-            const sourceFile = new Project().addSourceFileAtPath(sharedTypesPath);
-            const mentionedTypes = Array.from(fs.readFileSync(apiDocPath, "utf-8").matchAll(/`([^`]+)`/g)).map(m => m[1]).filter(t => /^[A-Z][a-zA-Z0-9]+(DTO|Response|Request|Status|Type)?$/.test(t));
+            if (!fs.existsSync(sharedTypesDir)) return { content: [{ type: "text", text: "Shared types directory not found." }] };
+
+            const project = new Project();
+            project.addSourceFilesAtPaths(path.join(sharedTypesDir, "**/*.ts"));
+
+            const mentionedTypes = Array.from(fs.readFileSync(apiDocPath, "utf-8").matchAll(/`([^`]+)`/g))
+                .map(m => m[1])
+                .filter(t => /^[A-Z][a-zA-Z0-9]+(DTO|Response|Request|Status|Type)?$/.test(t));
+
             const uniqueTypes = Array.from(new Set(mentionedTypes));
-            const missingTypes = uniqueTypes.filter(t => !sourceFile.getInterface(t) && !sourceFile.getTypeAlias(t) && !sourceFile.getEnum(t) && !sourceFile.getClass(t));
+            const missingTypes = uniqueTypes.filter(t => {
+                const found = project.getSourceFiles().some(sf => 
+                    sf.getInterface(t) || sf.getTypeAlias(t) || sf.getEnum(t) || sf.getClass(t)
+                );
+                return !found;
+            });
+
             return { content: [{ type: "text", text: `### CONTRACT INTEGRITY SHIELD: ${parsed.data.domain.toUpperCase()}\n\n` + `- **Missing/Undefined Types:** ${missingTypes.length > 0 ? `⚠️ ${missingTypes.join(", ")}` : "✅ All types synchronized"}\n\n` + `**Result:** ${missingTypes.length === 0 ? "PASSED" : "FAILED"}` }] };
         } catch (error) {
             return { content: [{ type: "text", text: "Contract verification failed." }] };

package/{packages/framework-mcp → framework-mcp}/src/tools/framework.ts

@@ -102,8 +102,9 @@ export const frameworkHandlers = {
         const missing: string[] = [];
         const frameworkDir = getFrameworkDir(projectRoot);
         const checkPaths = [
-            { path: "apps", type: "folder", optional: true },
-            { path: "packages/shared-types/src", type: "folder" },
+            { path: "apps/backend/src/types", type: "folder" },
+            { path: "apps/web/src/types", type: "folder" },
+            { path: "framework-mcp/src", type: "folder" },
             { path: path.join(frameworkDir, "docs/api"), type: "folder", optional: true },
             { path: ".env", type: "file", optional: true },
             { path: ".env.example", type: "file" },
@@ -174,8 +175,9 @@ export const frameworkHandlers = {
             const cliPath = path.join(projectRoot, "bin/cli.js");
             const output = execSync(`node ${cliPath} check`, { cwd: projectRoot, encoding: "utf-8", stdio: "pipe" });
             return { content: [{ type: "text", text: `### FRAMEWORK HEALTH CHECK\n\n${output}` }] };
-        } catch (error: any) {
-            return { content: [{ type: "text", text: `### FRAMEWORK HEALTH CHECK (FAILED)\n\n${error.stdout || error.message}` }] };
+        } catch (error: unknown) {
+            const err = error as { stdout?: string; message?: string };
+            return { content: [{ type: "text", text: `### FRAMEWORK HEALTH CHECK (FAILED)\n\n${err.stdout || err.message}` }] };
         }
     }
 };

package/{packages/framework-mcp → framework-mcp}/src/tools/git.ts

@@ -26,14 +26,13 @@ export const gitHandlers = {
             const files = execSync("git diff --staged --name-only", { encoding: "utf-8", cwd: projectRoot }).split("\n").filter(Boolean);
             let type = "feat", scope = "code";
             if (files.some(f => f.includes(".md"))) type = "docs";
-            else if (files.some(f => f.includes("shared-types"))) type = "arch";
+            else if (files.some(f => f.includes("apps/backend/src/types"))) type = "arch";
             else if (files.some(f => f.includes("framework-mcp"))) type = "chore";
             else if (files.some(f => f.includes("bin/cli.js"))) type = "fix";
             else if (files.some(f => f.includes("test"))) type = "test";
             if (files.some(f => f.includes("apps/web"))) scope = "web";
             else if (files.some(f => f.includes("apps/backend"))) scope = "backend";
-            else if (files.some(f => f.includes("packages/shared-types"))) scope = "contract";
-            else if (files.some(f => f.includes("packages/framework-mcp"))) scope = "mcp";
+            else if (files.some(f => f.includes("framework-mcp"))) scope = "mcp";
             const summary = files.length === 1 ? `update ${path.basename(files[0])}` : `update ${files.length} files`;
             return { content: [{ type: "text", text: `### SUGGESTED SEMANTIC COMMIT MESSAGE\n\n\`[${parsed.data.traceId}] ${type}(${scope}): ${summary}\`\n\n**Files Analyzed:**\n${files.map(f => `- ${f}`).join("\n")}` }] };
         } catch (error) {

package/{packages/framework-mcp → framework-mcp}/src/tools/index.ts

@@ -9,6 +9,7 @@ import { gitTools, gitHandlers } from "./git.js";
 import { databaseTools, databaseHandlers } from "./database.js";
 import { knowledgeTools, knowledgeHandlers } from "./knowledge.js";
 import { repositoryTools, repositoryHandlers } from "./repository.js";
+import { scaffoldTools, scaffoldHandlers } from "./scaffold.js";
 
 export const allTools = [
     ...codebaseTools,
@@ -22,6 +23,7 @@ export const allTools = [
     ...databaseTools,
     ...knowledgeTools,
     ...repositoryTools,
+    ...scaffoldTools,
 ];
 
 export const allHandlers: Record<string, (args: unknown, projectRoot: string) => Promise<unknown>> = {
@@ -36,6 +38,7 @@ export const allHandlers: Record<string, (args: unknown, projectRoot: string) =>
     ...databaseHandlers,
     ...knowledgeHandlers,
     ...repositoryHandlers,
+    ...scaffoldHandlers,
 };
 
 // Add compatibility aliases

package/{packages/framework-mcp → framework-mcp}/src/tools/knowledge.ts

@@ -48,15 +48,15 @@ function parseFrontmatter(content: string) {
     const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
     if (!match) return { metadata: {}, body: content };
     const yaml = match[1];
-    const metadata: Record<string, any> = {};
+    const metadata: Record<string, string | undefined> = {};
     yaml.split("\n").forEach(line => {
         const [key, ...val] = line.split(":");
         if (key && val.length > 0) metadata[key.trim()] = val.join(":").trim();
     });
     return { metadata, body: content.replace(match[0], "").trim() };
-}
+    }
 
-export const knowledgeHandlers = {
+    export const knowledgeHandlers = {
     search_knowledge_base: async (args: unknown, projectRoot: string) => {
         const parsed = SEARCH_KNOWLEDGE_BASE_ARGS_SCHEMA.safeParse(args ?? {});
         if (!parsed.success) return { content: [{ type: "text", text: "Invalid search query." }] };
@@ -64,12 +64,12 @@ export const knowledgeHandlers = {
             const frameworkDir = getFrameworkDir(projectRoot);
             const kbDir = path.join(projectRoot, frameworkDir, "knowledge");
             if (!fs.existsSync(kbDir)) return { content: [{ type: "text", text: "Knowledge base is empty." }] };
-            
+
             const query = parsed.data.query.toLowerCase();
             const results = fs.readdirSync(kbDir).filter(f => f.endsWith(".md")).map(file => {
                 const content = fs.readFileSync(path.join(kbDir, file), "utf-8");
                 const { metadata, body } = parseFrontmatter(content);
-                
+
                 const matchesQuery = body.toLowerCase().includes(query) || 
                                    file.toLowerCase().includes(query) ||
                                    (metadata.tags && metadata.tags.toLowerCase().includes(query)) ||
@@ -127,7 +127,7 @@ export const knowledgeHandlers = {
                 mermaid += `  ${id}["${label}"]\n`;
                 
                 if (metadata.related) {
-                    const related = metadata.related.replace(/[\[\]]/g, "").split(",");
+                    const related = metadata.related.replace(/[[\]]/g, "").split(",");
                     related.forEach((r: string) => {
                         mermaid += `  ${id} --> ${r.trim().replace(".md", "")}\n`;
                     });

package/{packages/framework-mcp → framework-mcp}/src/tools/repository.ts

@@ -93,7 +93,7 @@ export const repositoryHandlers = {
                     });
                 });
             }
-            const majorDirs = ["apps/backend", "apps/web", "packages/shared-types", "packages/framework-mcp"], missingREADME = majorDirs.filter(dir => fs.existsSync(path.join(projectRoot, dir)) && !fs.existsSync(path.join(projectRoot, dir, "README.md")));
+            const majorDirs = ["apps/backend", "apps/web", "framework-mcp"], missingREADME = majorDirs.filter(dir => fs.existsSync(path.join(projectRoot, dir)) && !fs.existsSync(path.join(projectRoot, dir, "README.md")));
             return { content: [{ type: "text", text: `### DOCUMENTATION DEBT REPORT\n\n**Missing JSDoc:**\n${missingJSDoc.slice(0, 10).join("\n")}\n\n**Missing README.md:**\n${missingREADME.join("\n")}` }] };
         } catch (error) {
             return { content: [{ type: "text", text: "Documentation debt scan failed." }] };

package/framework-mcp/src/tools/scaffold.ts

@@ -0,0 +1,147 @@
+import fs from "fs";
+import path from "path";
+import { 
+    resolveSafePath, 
+    getFrameworkDir 
+} from "../utils.js";
+import { 
+    INSTANTIATE_BLUEPRINT_ARGS_SCHEMA, 
+    LIST_BLUEPRINTS_ARGS_SCHEMA,
+    SAVE_AS_BLUEPRINT_ARGS_SCHEMA
+} from "../schemas.js";
+
+export const scaffoldTools = [
+    {
+        name: "instantiate_blueprint",
+        description: "Clones a Gold Standard capability from .enderun/blueprints into the application source.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                blueprintPath: { type: "string", description: "Relative path within blueprints/ (e.g., backend/errors)" },
+                targetPath: { type: "string", description: "Target directory in the app (e.g., apps/backend/src/errors)" },
+            },
+            required: ["blueprintPath", "targetPath"],
+        },
+    },
+    {
+        name: "save_as_blueprint",
+        description: "Saves or updates a high-quality code pattern as a Gold Standard blueprint for reuse.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                blueprintPath: { type: "string", description: "Target relative path in blueprints/ (e.g., frontend/ui/Button.tsx)" },
+                content: { type: "string", description: "The full source code of the blueprint" },
+                description: { type: "string", description: "Brief description of what this blueprint provides" },
+            },
+            required: ["blueprintPath", "content"],
+        },
+    },
+    {
+        name: "list_blueprints",
+        description: "Lists all available Gold Standard blueprints in the framework.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                category: { type: "string", enum: ["backend", "frontend"], description: "Optional category to filter blueprints" },
+            },
+        },
+    },
+];
+
+export const scaffoldHandlers = {
+    instantiate_blueprint: async (args: unknown, projectRoot: string) => {
+        const parsed = INSTANTIATE_BLUEPRINT_ARGS_SCHEMA.safeParse(args);
+        if (!parsed.success) return { content: [{ type: "text", text: `Invalid arguments: ${parsed.error.message}` }] };
+
+        const { blueprintPath, targetPath } = parsed.data;
+        const frameworkDir = getFrameworkDir(projectRoot);
+        const sourceDir = resolveSafePath(projectRoot, path.join(frameworkDir, "blueprints", blueprintPath));
+        const destDir = resolveSafePath(projectRoot, targetPath);
+
+        try {
+            if (!fs.existsSync(sourceDir)) {
+                return { content: [{ type: "text", text: `Blueprint not found: ${blueprintPath}` }] };
+            }
+
+            // Create target directory if it doesn't exist
+            fs.mkdirSync(path.dirname(destDir), { recursive: true });
+
+            // Copy recursively
+            // Using cpSync which is available in Node.js 16.7.0+
+            fs.cpSync(sourceDir, destDir, { recursive: true });
+
+            return { content: [{ type: "text", text: `Successfully instantiated blueprint '${blueprintPath}' into '${targetPath}'` }] };
+        } catch (error: any) {
+            return { content: [{ type: "text", text: `Scaffold failed: ${error.message}` }] };
+        }
+    },
+    save_as_blueprint: async (args: unknown, projectRoot: string) => {
+        const parsed = SAVE_AS_BLUEPRINT_ARGS_SCHEMA.safeParse(args);
+        if (!parsed.success) return { content: [{ type: "text", text: `Invalid arguments: ${parsed.error.message}` }] };
+
+        const { blueprintPath, content, description } = parsed.data;
+        const frameworkDir = getFrameworkDir(projectRoot);
+        const targetFile = resolveSafePath(projectRoot, path.join(frameworkDir, "blueprints", blueprintPath));
+
+        try {
+            // Ensure the blueprints subdirectory exists
+            fs.mkdirSync(path.dirname(targetFile), { recursive: true });
+            
+            // Write the blueprint content
+            fs.writeFileSync(targetFile, content, "utf-8");
+
+            // Optionally write a .metadata file if description provided
+            if (description) {
+                const metaFile = `${targetFile}.metadata.json`;
+                fs.writeFileSync(metaFile, JSON.stringify({ description, savedAt: new Date().toISOString() }, null, 2), "utf-8");
+            }
+
+            return { content: [{ type: "text", text: `Successfully saved blueprint to '${blueprintPath}'` }] };
+        } catch (error: any) {
+            return { content: [{ type: "text", text: `Failed to save blueprint: ${error.message}` }] };
+        }
+    },
+    list_blueprints: async (args: unknown, projectRoot: string) => {
+        const parsed = LIST_BLUEPRINTS_ARGS_SCHEMA.safeParse(args ?? {});
+        const category = parsed.success ? parsed.data.category : undefined;
+        const frameworkDir = getFrameworkDir(projectRoot);
+        const blueprintsRoot = path.join(projectRoot, frameworkDir, "blueprints");
+
+        try {
+            if (!fs.existsSync(blueprintsRoot)) {
+                return { content: [{ type: "text", text: "Blueprints directory not found." }] };
+            }
+
+            const walk = (dir: string): string[] => {
+                const results: string[] = [];
+                if (!fs.existsSync(dir)) return results;
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const res = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        // If it's a leaf directory containing files, or we want to show all dirs
+                        const subEntries = fs.readdirSync(res);
+                        const hasFiles = subEntries.some(e => !fs.lstatSync(path.join(res, e)).isDirectory());
+                        if (hasFiles) {
+                            results.push(path.relative(blueprintsRoot, res));
+                        }
+                        results.push(...walk(res));
+                    }
+                }
+                return results;
+            };
+
+            let available = walk(blueprintsRoot);
+            if (category) {
+                available = available.filter(b => b.startsWith(category));
+            }
+
+            // Remove duplicates
+            available = Array.from(new Set(available));
+
+            return { content: [{ type: "text", text: `### AVAILABLE BLUEPRINTS\n\n` + available.map(b => `- ${b}`).join("\n") }] };
+        } catch (error: any) {
+            return { content: [{ type: "text", text: `Listing blueprints failed: ${error.message}` }] };
+        }
+    },
+};

package/{packages/framework-mcp → framework-mcp}/src/utils.ts

@@ -1,7 +1,7 @@
 import path from "path";
 import fs from "fs";
 
-export const FRAMEWORK_VERSION = "0.5.8";
+export const FRAMEWORK_VERSION = "0.6.0";
 
 export function getFrameworkDir(projectRoot: string): string {
     const adapters = [".gemini", ".claude", ".cursor", ".enderun", ".codex"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-enderun",
-  "version": "0.5.8",
+  "version": "0.6.0",
   "description": "The Supreme AI Governance & Orchestration Framework for Enterprise Development",
   "author": "Yusuf BEKAR",
   "license": "MIT",
@@ -24,21 +24,17 @@
     "framework"
   ],
   "workspaces": [
-    "packages/*",
-    "apps/*"
+    "apps/*",
+    "framework-mcp"
   ],
   "bin": {
     "agent-enderun": "bin/cli.js"
   },
   "files": [
     "bin",
-    "packages/shared-types/dist",
-    "packages/shared-types/src",
-    "packages/shared-types/package.json",
-    "packages/shared-types/contract.version.json",
-    "packages/framework-mcp/dist",
-    "packages/framework-mcp/src",
-    "packages/framework-mcp/package.json",
+    "framework-mcp/dist",
+    "framework-mcp/src",
+    "framework-mcp/package.json",
     ".enderun",
     "ENDERUN.md",
     "README.md",
@@ -55,7 +51,7 @@
     "docs"
   ],
   "scripts": {
-    "enderun:build": "npm run build --prefix packages/shared-types && npm run build --prefix packages/framework-mcp",
+    "enderun:build": "npm run build --prefix framework-mcp",
     "enderun:test": "vitest run",
     "enderun:test:watch": "vitest",
     "enderun:status": "agent-enderun status",
@@ -80,7 +76,7 @@
     "@pandacss/dev": "^0.53.0"
   },
   "enderun": {
-    "version": "0.5.8",
+    "version": "0.5.9",
     "initializedAt": "2026-05-19T14:23:38.760Z"
   },
   "dependencies": {}