agent-enderun 0.7.2 → 0.8.0

package/docs/backend/audit-logging.md

@@ -1,34 +0,0 @@
-# Backend Audit Logging & Observability
-
-This document defines the schema, storage criteria, and compliance guidelines for transactional database audit logs.
-
----
-
-## 🔒 Audit Log Schema
-
-Every state-changing transaction (Insert, Update, Delete) must generate a secure, untamperable audit record with this exact schema:
-
-```json
-{
-  "timestamp": "2026-05-24T12:00:00.000Z",
-  "userId": "usr_91a0b3...",
-  "operation": "UPDATE",
-  "targetTable": "users",
-  "targetRowId": "42",
-  "previousState": {
-    "role": "User",
-    "status": "Active"
-  },
-  "newState": {
-    "role": "SuperAdmin",
-    "status": "Active"
-  },
-  "traceId": "01H...",
-  "managerApprovalSignature": "approved_sig_payload_hash"
-}
-```
-
----
-
-> [!WARNING]
-> **Data Privacy:** Audit logs must never contain raw PII (Personally Identifiable Information) such as unhashed passwords, credit card tokens, or cleartext social security numbers.

package/docs/frontend/forms.md

@@ -1,40 +0,0 @@
-# Type-Safe Forms with Zod Validations
-
-Guidelines for building highly responsive, type-safe web forms using React state hooks and Zod validation schemas.
-
----
-
-## 📝 Form Validation Pattern
-
-Always decouple validation schemas from the component render context:
-
-```typescript
-import { z } from "zod";
-
-export const CreateUserFormSchema = z.object({
-  email: z.string().email("Invalid email address"),
-  role: z.enum(["admin", "editor", "user"]),
-  fullName: z.string().min(2, "Full name must be at least 2 characters")
-});
-```
-
-Verify states on submit:
-
-```tsx
-const onSubmit = (data: unknown) => {
-  const result = CreateUserFormSchema.safeParse(data);
-  if (!result.success) {
-    const fieldErrors = result.error.formErrors.fieldErrors;
-    setErrors(fieldErrors);
-    return;
-  }
-  
-  // Submit verified payload
-  submitPayload(result.data);
-};
-```
-
----
-
-> [!IMPORTANT]
-> **Keyboard Traps:** Ensure form fields support keyboard navigation (`Tab` index navigation) and submit correctly upon hitting `Enter` when inside an active field.

package/docs/frontend/notifications.md

@@ -1,37 +0,0 @@
-# Frontend Notifications & Sonner Toaster Integration
-
-This document defines the integration steps, design tokens, and accessibility standards for frontend notifications inside your React/Vite applications.
-
----
-
-## 💻 Toaster Configuration
-
-Place the custom Sonner Toaster container in your root layout:
-
-```tsx
-import { Toaster } from "sonner";
-
-export const RootLayout = ({ children }) => {
-  return (
-    <>
-      <Toaster 
-        theme="dark" 
-        position="bottom-right" 
-        toastOptions={{
-          style: {
-            background: "#121214",
-            border: "1px solid #29292e",
-            color: "#e1e1e6"
-          }
-        }}
-      />
-      <main>{children}</main>
-    </>
-  );
-};
-```
-
----
-
-> [!TIP]
-> **Dynamic Action Toasts:** For high-risk administrative operations (such as user suspends), toast messages must present a valid action hook button to undo the action instantly.

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

@@ -1,182 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { getFrameworkDir } from "../utils.js";
-import { GET_ACADEMY_PERFORMANCE_ARGS_SCHEMA, GET_AGENT_AUDIT_REPORT_ARGS_SCHEMA, LOG_AGENT_ACTION_ARGS_SCHEMA } from "../schemas.js";
-export const academyTools = [
-    {
-        name: "get_academy_performance",
-        description: "Aggregates performance data from all agents to provide a global overview of the Academy's health and intelligence growth.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                periodDays: {
-                    type: "number",
-                    description: "Number of days to include in the report",
-                    default: 30,
-                },
-            },
-        },
-    },
-    {
-        name: "generate_strategic_briefing",
-        description: "Generates a high-level strategic briefing for the user, summarizing Academy health, progress, and future strategy.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                focusArea: {
-                    type: "string",
-                    description: "Optional area to focus on (e.g. 'quality', 'velocity', 'architecture')",
-                },
-            },
-        },
-    },
-    {
-        name: "generate_academy_progress_report",
-        description: "Generates a comprehensive narrative report on the Academy's progress, milestones, and challenges.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                days: {
-                    type: "number",
-                    description: "Number of days to include in the report",
-                    default: 7,
-                },
-            },
-        },
-    },
-    {
-        name: "get_agent_audit_report",
-        description: "Generates a summary report of an agent's activities based on their logs. Useful for self-improvement and progress tracking.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                agent: {
-                    type: "string",
-                    description: "Agent name (e.g. analyst, backend)",
-                },
-                days: {
-                    type: "number",
-                    description: "Number of recent days to analyze",
-                    default: 7,
-                },
-            },
-            required: ["agent"],
-        },
-    },
-    {
-        name: "log_agent_action",
-        description: "Safely append a structured log entry to the agent's log file.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                agent: { type: "string", description: "Agent name" },
-                action: { type: "string", description: "Action performed" },
-                requestId: { type: "string", description: "Trace ID or Request ID" },
-                files: { type: "array", items: { type: "string" }, description: "Files affected" },
-                status: { type: "string", enum: ["SUCCESS", "FAILURE"], description: "Action status" },
-                summary: { type: "string", description: "Short English summary" },
-                details: { type: "object", description: "Additional details" },
-            },
-            required: ["agent", "action", "requestId", "status", "summary"],
-        },
-    },
-];
-export const academyHandlers = {
-    get_academy_performance: async (args, projectRoot) => {
-        const parsed = GET_ACADEMY_PERFORMANCE_ARGS_SCHEMA.safeParse(args ?? {});
-        const days = parsed.success ? parsed.data.periodDays : 30;
-        try {
-            const frameworkDir = getFrameworkDir(projectRoot);
-            const logsDir = path.join(projectRoot, frameworkDir, "logs");
-            if (!fs.existsSync(logsDir))
-                return { content: [{ type: "text", text: "No logs found." }] };
-            const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
-            let totalActions = 0, totalSuccess = 0;
-            const agentStats = fs.readdirSync(logsDir).filter(f => f.endsWith(".json")).map(file => {
-                const logs = JSON.parse(fs.readFileSync(path.join(logsDir, file), "utf-8")).filter((l) => new Date(l.timestamp) >= cutoff);
-                const success = logs.filter((l) => l.status === "SUCCESS").length;
-                totalActions += logs.length;
-                totalSuccess += success;
-                return { agent: file.replace(".json", ""), actions: logs.length, successRate: (success / (logs.length || 1)) * 100 };
-            }).filter(s => s.actions > 0);
-            return { content: [{ type: "text", text: `### GLOBAL ACADEMY PERFORMANCE REPORT\n\n- **Analysis Period:** Last ${days} days\n- **Global Success Rate:** ${((totalSuccess / (totalActions || 1)) * 100).toFixed(1)}%\n\n**Agent Breakdown:**\n` + agentStats.map(s => `- **@${s.agent}:** ${s.actions} actions (${s.successRate.toFixed(1)}% success)`).join("\n") }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Failed to generate global performance report." }] };
-        }
-    },
-    generate_strategic_briefing: async (args, projectRoot) => {
-        try {
-            const frameworkDir = getFrameworkDir(projectRoot);
-            const logsDir = path.join(projectRoot, frameworkDir, "logs");
-            let totalActions = 0, successCount = 0;
-            if (fs.existsSync(logsDir)) {
-                fs.readdirSync(logsDir).filter(f => f.endsWith(".json")).forEach(file => {
-                    const logs = JSON.parse(fs.readFileSync(path.join(logsDir, file), "utf-8"));
-                    totalActions += logs.length;
-                    successCount += logs.filter((l) => l.status === "SUCCESS").length;
-                });
-            }
-            const successRate = (successCount / (totalActions || 1)) * 100;
-            return { content: [{ type: "text", text: `# 🏛️ ACADEMY STRATEGIC BRIEFING\n\n- **Academy Health:** ${successRate.toFixed(1)}% Success Rate over ${totalActions} actions.\n**Status:** READY FOR PHASE_1 COMPLETION.` }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Strategic briefing generation failed." }] };
-        }
-    },
-    generate_academy_progress_report: async (args, projectRoot) => {
-        try {
-            const frameworkDir = getFrameworkDir(projectRoot);
-            const memoryPath = path.join(projectRoot, frameworkDir, "PROJECT_MEMORY.md");
-            const memoryContent = fs.existsSync(memoryPath) ? fs.readFileSync(memoryPath, "utf-8") : "";
-            const historySection = memoryContent.match(/## HISTORY[\s\S]*$/m)?.[0] ?? "";
-            const milestones = Array.from(historySection.matchAll(/### (.*)\n\n- \*\*Agent:\*\* (.*)\n- \*\*Trace ID:\*\* (.*)\n- \*\*Action:\*\* (.*)/g)).slice(0, 5).map(m => `- [${m[1]}] **${m[2]}:** ${m[4]}`).join("\n");
-            return { content: [{ type: "text", text: `# 🎓 AGENT ACADEMY PROGRESS REPORT\n\n## 🏆 Key Milestones Achieved\n${milestones}` }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Failed to generate progress report." }] };
-        }
-    },
-    get_agent_audit_report: async (args, projectRoot) => {
-        const parsed = GET_AGENT_AUDIT_REPORT_ARGS_SCHEMA.safeParse(args ?? {});
-        if (!parsed.success)
-            return { content: [{ type: "text", text: "Invalid agent or days argument." }] };
-        try {
-            const frameworkDir = getFrameworkDir(projectRoot);
-            const logPath = path.join(projectRoot, frameworkDir, "logs", `${parsed.data.agent}.json`);
-            if (!fs.existsSync(logPath))
-                return { content: [{ type: "text", text: `No logs found for agent: ${parsed.data.agent}` }] };
-            const cutoff = new Date(Date.now() - parsed.data.days * 24 * 60 * 60 * 1000);
-            const logs = JSON.parse(fs.readFileSync(logPath, "utf-8")).filter((l) => new Date(l.timestamp) >= cutoff);
-            const successCount = logs.filter((l) => l.status === "SUCCESS").length;
-            return { content: [{ type: "text", text: `### AGENT AUDIT REPORT: ${parsed.data.agent.toUpperCase()}\n\n- **Total Actions:** ${logs.length}\n- **Success Rate:** ${((successCount / (logs.length || 1)) * 100).toFixed(1)}%` }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Failed to generate audit report." }] };
-        }
-    },
-    log_agent_action: async (args, projectRoot) => {
-        const parsed = LOG_AGENT_ACTION_ARGS_SCHEMA.safeParse(args ?? {});
-        if (!parsed.success)
-            return { content: [{ type: "text", text: "Invalid arguments for log_agent_action." }] };
-        try {
-            const frameworkDir = getFrameworkDir(projectRoot);
-            const logsDir = path.join(projectRoot, frameworkDir, "logs");
-            if (!fs.existsSync(logsDir))
-                fs.mkdirSync(logsDir, { recursive: true });
-            const logPath = path.join(logsDir, `${parsed.data.agent}.json`);
-            let logs = fs.existsSync(logPath) ? JSON.parse(fs.readFileSync(logPath, "utf-8")) : [];
-            if (!Array.isArray(logs))
-                logs = [];
-            const requestId = parsed.data.requestId;
-            if (requestId !== "—" && !/^[0-9A-Z]{26}$/.test(requestId))
-                return { content: [{ type: "text", text: "ERROR: requestId MUST be a 26-character ULID." }] };
-            logs.push({ timestamp: new Date().toISOString(), ...parsed.data });
-            fs.writeFileSync(logPath, JSON.stringify(logs, null, 2));
-            return { content: [{ type: "text", text: `SUCCESS: Logged action to ${parsed.data.agent}.json` }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Failed to log action." }] };
-        }
-    },
-};

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

@@ -1,57 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { Project } from "ts-morph";
-import { resolveSafePath } from "../utils.js";
-import { ANALYZE_DATABASE_SCHEMA_ARGS_SCHEMA } from "../schemas.js";
-export const databaseTools = [
-    {
-        name: "analyze_database_schema",
-        description: "Scans the backend codebase (e.g., Kysely migrations or Prisma schemas) to extract and visualize the database schema as a Mermaid ER diagram.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: { type: "string", description: "Path to scan for DB definitions", default: "apps/backend" },
-            },
-        },
-    },
-];
-export const databaseHandlers = {
-    analyze_database_schema: async (args, projectRoot) => {
-        const parsed = ANALYZE_DATABASE_SCHEMA_ARGS_SCHEMA.safeParse(args ?? {});
-        const targetPath = parsed.success ? parsed.data.path : "apps/backend";
-        try {
-            const safeTargetPath = resolveSafePath(projectRoot, targetPath);
-            if (!fs.existsSync(safeTargetPath))
-                return { content: [{ type: "text", text: "Database path not found." }] };
-            const tsProject = new Project();
-            tsProject.addSourceFilesAtPaths(path.join(safeTargetPath, "**/*.{ts,tsx}"));
-            let mermaid = "erDiagram\n", tablesFound = 0;
-            for (const sourceFile of tsProject.getSourceFiles()) {
-                const text = sourceFile.getFullText();
-                const tableMatches = Array.from(text.matchAll(/\.createTable\(['"]([^'"]+)['"]\)/g));
-                for (let i = 0; i < tableMatches.length; i++) {
-                    const match = tableMatches[i];
-                    const tableName = match[1];
-                    tablesFound++;
-                    mermaid += `  ${tableName} {\n`;
-                    const startIndex = match.index ?? 0;
-                    const nextMatch = tableMatches[i + 1];
-                    const endIndex = nextMatch ? (nextMatch.index ?? text.length) : text.length;
-                    const tableBlockText = text.substring(startIndex, endIndex);
-                    const colRegex = /\.addColumn\(['"]([^'"]+)['"]\s*,\s*['"]([^'"]+)['"]/g;
-                    let colMatch;
-                    while ((colMatch = colRegex.exec(tableBlockText)) !== null) {
-                        mermaid += `    ${colMatch[2].replace(/[^a-zA-Z0-9]/g, '_')} ${colMatch[1]}\n`;
-                    }
-                    mermaid += `  }\n`;
-                }
-            }
-            if (tablesFound === 0)
-                return { content: [{ type: "text", text: "No database tables detected." }] };
-            return { content: [{ type: "text", text: `### DATABASE SCHEMA MAP\n\n\`\`\`mermaid\n${mermaid}\n\`\`\`\n\n**Total Tables Detected:** ${tablesFound}` }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Database schema analysis failed." }] };
-        }
-    },
-};

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

@@ -1,101 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { spawnSync } from "child_process";
-import { Project } from "ts-morph";
-import { resolveSafePath } from "../utils.js";
-import { VALIDATE_REPOSITORY_HEALTH_ARGS_SCHEMA, ANALYZE_DOCUMENTATION_DEBT_ARGS_SCHEMA } from "../schemas.js";
-export const repositoryTools = [
-    {
-        name: "validate_repository_health",
-        description: "Runs project health checks (lint, test, build) before critical actions like commits.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                scope: { type: "string", enum: ["full", "lint", "test", "build"], default: "full" },
-            },
-        },
-    },
-    {
-        name: "analyze_documentation_debt",
-        description: "Scans the codebase for missing documentation, including JSDoc, READMEs, and API contracts.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: { type: "string", description: "Path to scan (relative to project root)", default: "." },
-            },
-        },
-    },
-];
-export const repositoryHandlers = {
-    validate_repository_health: async (args, projectRoot) => {
-        const parsed = VALIDATE_REPOSITORY_HEALTH_ARGS_SCHEMA.safeParse(args ?? {});
-        const scope = parsed.success ? parsed.data.scope : "full";
-        try {
-            const pkgPath = path.join(projectRoot, "package.json");
-            if (!fs.existsSync(pkgPath))
-                return { content: [{ type: "text", text: "package.json not found." }] };
-            const scripts = JSON.parse(fs.readFileSync(pkgPath, "utf-8")).scripts || {};
-            const scriptCandidates = {
-                lint: ["lint", "enderun:lint"],
-                test: ["test", "enderun:test"],
-                build: ["build", "enderun:build"],
-            };
-            const runScript = (name) => {
-                const scriptName = scriptCandidates[name].find((candidate) => scripts[candidate]);
-                if (!scriptName)
-                    return { name, script: "-", status: "SKIPPED", details: "No matching script found." };
-                const result = spawnSync("npm", ["run", scriptName], {
-                    cwd: projectRoot,
-                    encoding: "utf-8",
-                    stdio: "pipe",
-                });
-                const output = `${result.stdout || ""}${result.stderr || ""}`.trim();
-                return {
-                    name,
-                    script: scriptName,
-                    status: result.status === 0 ? "PASSED" : "FAILED",
-                    details: output.split("\n").slice(-5).join("\n"),
-                };
-            };
-            const results = [];
-            if (scope === "full" || scope === "lint")
-                results.push(runScript("lint"));
-            if (scope === "full" || scope === "test")
-                results.push(runScript("test"));
-            if (scope === "full" || scope === "build")
-                results.push(runScript("build"));
-            return { content: [{ type: "text", text: `### REPOSITORY HEALTH REPORT\n\n` + results.map(r => `- **${r.name.toUpperCase()}** (${r.script}): ${r.status}${r.status === "FAILED" && r.details ? `\n  ${r.details}` : ""}`).join("\n") }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Failed to analyze repository health." }] };
-        }
-    },
-    analyze_documentation_debt: async (args, projectRoot) => {
-        const parsed = ANALYZE_DOCUMENTATION_DEBT_ARGS_SCHEMA.safeParse(args ?? {});
-        const targetPath = parsed.success ? parsed.data.path : ".";
-        try {
-            const safeTargetPath = resolveSafePath(projectRoot, targetPath);
-            const tsProject = new Project();
-            tsProject.addSourceFilesAtPaths(path.join(safeTargetPath, "**/*.{ts,tsx}"));
-            const missingJSDoc = [];
-            for (const sourceFile of tsProject.getSourceFiles()) {
-                const relativePath = path.relative(projectRoot, sourceFile.getFilePath());
-                if (relativePath.includes("node_modules") || relativePath.includes("dist"))
-                    continue;
-                sourceFile.getExportedDeclarations().forEach((declarations, name) => {
-                    declarations.forEach(decl => {
-                        const d = decl;
-                        if (typeof d.getJsDocs === "function" && d.getJsDocs().length === 0) {
-                            missingJSDoc.push(`${relativePath} -> ${name}`);
-                        }
-                    });
-                });
-            }
-            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 {
-            return { content: [{ type: "text", text: "Failed to analyze documentation debt." }] };
-        }
-    },
-};

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

@@ -1,132 +0,0 @@
-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) {
-            const message = error instanceof Error ? error.message : "Unknown error";
-            return { content: [{ type: "text", text: `Scaffold failed: ${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) {
-            const message = error instanceof Error ? error.message : "Unknown error";
-            return { content: [{ type: "text", text: `Failed to save blueprint: ${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) {
-            const message = error instanceof Error ? error.message : "Unknown error";
-            return { content: [{ type: "text", text: `Listing blueprints failed: ${message}` }] };
-        }
-    },
-};