agent-enderun 0.8.7 → 0.9.0

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

@@ -1,267 +0,0 @@
-import { promises as fs } from "fs";
-import path from "path";
-// ─── Tool Definitions ─────────────────────────────────────────────────────────
-export const pipelineTools = [
-    {
-        name: "create_execution_pipeline",
-        description: "Creates a multi-stage execution pipeline for complex workflows (e.g., build → test → security audit → deploy). Each stage is assigned to a specific agent and has defined dependencies. The pipeline is persisted and can be advanced or rolled back.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                traceId: { type: "string", description: "Active Trace ID from @manager briefing" },
-                name: { type: "string", description: "Pipeline name (e.g. 'Production Deploy v1.2.0')" },
-                description: { type: "string", description: "What this pipeline accomplishes" },
-                stages: {
-                    type: "array",
-                    description: "Ordered pipeline stages",
-                    items: {
-                        type: "object",
-                        required: ["id", "name", "agent"],
-                        properties: {
-                            id: { type: "string" },
-                            name: { type: "string" },
-                            agent: { type: "string" },
-                            dependsOn: { type: "array", items: { type: "string" } },
-                        },
-                    },
-                },
-                rollbackStages: {
-                    type: "array",
-                    description: "Optional rollback stages executed in reverse order on pipeline failure",
-                    items: {
-                        type: "object",
-                        required: ["id", "name", "agent"],
-                        properties: {
-                            id: { type: "string" },
-                            name: { type: "string" },
-                            agent: { type: "string" },
-                            dependsOn: { type: "array", items: { type: "string" } },
-                        },
-                    },
-                },
-            },
-            required: ["traceId", "name", "stages"],
-        },
-    },
-    {
-        name: "advance_pipeline_stage",
-        description: "Advances a pipeline to the next eligible stage. Marks the current stage as COMPLETED and activates all dependent stages that now have their dependencies satisfied. Returns the new pipeline state.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                pipelineId: { type: "string", description: "Pipeline ID" },
-                completedStageId: { type: "string", description: "The stage that just completed successfully" },
-                stageOutput: { type: "string", description: "Optional output/result from the completed stage" },
-            },
-            required: ["pipelineId", "completedStageId"],
-        },
-    },
-    {
-        name: "rollback_pipeline",
-        description: "Rolls back a pipeline to the last stable state by executing the defined rollback stages in reverse order. Updates the pipeline status to ROLLED_BACK.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                pipelineId: { type: "string", description: "Pipeline ID to roll back" },
-                reason: { type: "string", description: "Reason for the rollback (mandatory for audit)" },
-            },
-            required: ["pipelineId", "reason"],
-        },
-    },
-    {
-        name: "get_pipeline_status",
-        description: "Returns the full current status of a pipeline including all stage states, progress percentage, blocking stages, and estimated completion.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                pipelineId: { type: "string", description: "Pipeline ID" },
-            },
-            required: ["pipelineId"],
-        },
-    },
-];
-// ─── Handlers ─────────────────────────────────────────────────────────────────
-export const pipelineHandlers = {
-    async create_execution_pipeline(args, projectRoot) {
-        const { traceId, name, description, stages, rollbackStages } = args;
-        const pipelineId = `PIPE-${traceId}-${Date.now()}`;
-        const now = new Date().toISOString();
-        const pipeline = {
-            id: pipelineId,
-            traceId,
-            name,
-            description: description ?? "",
-            createdAt: now,
-            updatedAt: now,
-            status: "PENDING",
-            stages: stages.map((s) => ({
-                ...s,
-                dependsOn: s.dependsOn ?? [],
-                status: "PENDING",
-            })),
-            rollbackStages: rollbackStages?.map((s) => ({
-                ...s,
-                dependsOn: s.dependsOn ?? [],
-                status: "PENDING",
-            })),
-        };
-        // Activate stages with no dependencies
-        for (const stage of pipeline.stages) {
-            if (stage.dependsOn.length === 0) {
-                stage.status = "RUNNING";
-                stage.startedAt = now;
-            }
-        }
-        pipeline.status = "RUNNING";
-        // Persist pipeline
-        const pipelineDir = path.join(projectRoot, ".enderun", "queue", "pipelines");
-        await fs.mkdir(pipelineDir, { recursive: true });
-        await fs.writeFile(path.join(pipelineDir, `${pipelineId}.json`), JSON.stringify(pipeline, null, 2), "utf-8");
-        return { content: [{ type: "text", text: JSON.stringify(pipeline, null, 2) }] };
-    },
-    async advance_pipeline_stage(args, projectRoot) {
-        const { pipelineId, completedStageId, stageOutput } = args;
-        const pipelineDir = path.join(projectRoot, ".enderun", "queue", "pipelines");
-        const pipelinePath = path.join(pipelineDir, `${pipelineId}.json`);
-        let pipeline;
-        try {
-            const content = await fs.readFile(pipelinePath, "utf-8");
-            pipeline = JSON.parse(content);
-        }
-        catch {
-            return {
-                content: [
-                    { type: "text", text: JSON.stringify({ error: "PIPELINE_NOT_FOUND", pipelineId }) },
-                ],
-            };
-        }
-        const now = new Date().toISOString();
-        // Mark completed stage
-        const completedStage = pipeline.stages.find((s) => s.id === completedStageId);
-        if (!completedStage) {
-            return {
-                content: [
-                    { type: "text", text: JSON.stringify({ error: "STAGE_NOT_FOUND", completedStageId }) },
-                ],
-            };
-        }
-        completedStage.status = "COMPLETED";
-        completedStage.completedAt = now;
-        if (stageOutput)
-            completedStage.output = stageOutput;
-        // Activate newly unblocked stages
-        const completedIds = new Set(pipeline.stages.filter((s) => s.status === "COMPLETED").map((s) => s.id));
-        const newlyActivated = [];
-        for (const stage of pipeline.stages) {
-            if (stage.status === "PENDING" && stage.dependsOn.every((dep) => completedIds.has(dep))) {
-                stage.status = "RUNNING";
-                stage.startedAt = now;
-                newlyActivated.push(stage.id);
-            }
-        }
-        // Check if pipeline is complete
-        const allDone = pipeline.stages.every((s) => s.status === "COMPLETED");
-        if (allDone) {
-            pipeline.status = "COMPLETED";
-        }
-        pipeline.updatedAt = now;
-        await fs.writeFile(pipelinePath, JSON.stringify(pipeline, null, 2), "utf-8");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({ pipeline, newlyActivatedStages: newlyActivated }, null, 2),
-                },
-            ],
-        };
-    },
-    async rollback_pipeline(args, projectRoot) {
-        const { pipelineId, reason } = args;
-        const pipelineDir = path.join(projectRoot, ".enderun", "queue", "pipelines");
-        const pipelinePath = path.join(pipelineDir, `${pipelineId}.json`);
-        let pipeline;
-        try {
-            const content = await fs.readFile(pipelinePath, "utf-8");
-            pipeline = JSON.parse(content);
-        }
-        catch {
-            return {
-                content: [
-                    { type: "text", text: JSON.stringify({ error: "PIPELINE_NOT_FOUND", pipelineId }) },
-                ],
-            };
-        }
-        const now = new Date().toISOString();
-        pipeline.status = "ROLLED_BACK";
-        pipeline.updatedAt = now;
-        // Mark all non-completed stages as SKIPPED
-        for (const stage of pipeline.stages) {
-            if (stage.status === "RUNNING" || stage.status === "PENDING") {
-                stage.status = "SKIPPED";
-            }
-        }
-        // Activate rollback stages if defined
-        if (pipeline.rollbackStages) {
-            for (const stage of pipeline.rollbackStages) {
-                stage.status = "RUNNING";
-                stage.startedAt = now;
-            }
-        }
-        await fs.writeFile(pipelinePath, JSON.stringify(pipeline, null, 2), "utf-8");
-        // Write rollback event to devops log
-        const devopsLogPath = path.join(projectRoot, ".enderun", "logs", "devops.json");
-        let devopsLog = { rollbacks: [] };
-        try {
-            const existing = await fs.readFile(devopsLogPath, "utf-8");
-            devopsLog = JSON.parse(existing);
-            if (!devopsLog.rollbacks)
-                devopsLog.rollbacks = [];
-        }
-        catch {
-            // Start fresh
-        }
-        devopsLog.rollbacks.push({ pipelineId, reason, timestamp: now });
-        await fs.mkdir(path.dirname(devopsLogPath), { recursive: true });
-        await fs.writeFile(devopsLogPath, JSON.stringify(devopsLog, null, 2), "utf-8");
-        return { content: [{ type: "text", text: JSON.stringify({ pipeline, rollbackReason: reason }, null, 2) }] };
-    },
-    async get_pipeline_status(args, projectRoot) {
-        const { pipelineId } = args;
-        const pipelinePath = path.join(projectRoot, ".enderun", "queue", "pipelines", `${pipelineId}.json`);
-        try {
-            const content = await fs.readFile(pipelinePath, "utf-8");
-            const pipeline = JSON.parse(content);
-            const total = pipeline.stages.length;
-            const completed = pipeline.stages.filter((s) => s.status === "COMPLETED").length;
-            const running = pipeline.stages.filter((s) => s.status === "RUNNING").map((s) => s.id);
-            const blocked = pipeline.stages.filter((s) => s.status === "PENDING" && s.dependsOn.some((dep) => {
-                const depStage = pipeline.stages.find((st) => st.id === dep);
-                return depStage && depStage.status !== "COMPLETED";
-            })).map((s) => s.id);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            pipelineId,
-                            name: pipeline.name,
-                            status: pipeline.status,
-                            progress: `${completed}/${total} stages (${Math.round((completed / total) * 100)}%)`,
-                            currentlyRunning: running,
-                            waitingOn: blocked,
-                            createdAt: pipeline.createdAt,
-                            updatedAt: pipeline.updatedAt,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch {
-            return {
-                content: [
-                    { type: "text", text: JSON.stringify({ error: "PIPELINE_NOT_FOUND", pipelineId }) },
-                ],
-            };
-        }
-    },
-};

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

@@ -1,137 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { Project, SyntaxKind } from "ts-morph";
-import { collectFilesRecursively, resolveSafePath, buildLineMatches } from "../utils.js";
-import { SECURITY_AUDIT_ARGS_SCHEMA, ANALYZE_CONSTITUTION_COMPLIANCE_ARGS_SCHEMA } from "../schemas.js";
-export const securityTools = [
-    {
-        name: "security_audit_scan",
-        description: "Scans the codebase for security vulnerabilities like hardcoded secrets, raw SQL, and unsafe async patterns.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: {
-                    type: "string",
-                    description: "Path to scan (relative to project root)",
-                    default: ".",
-                },
-            },
-        },
-    },
-    {
-        name: "analyze_constitution_compliance",
-        description: "Scans a file or directory for violations of the project's ENDERUN.md rules (e.g. Zero UI Library, Branded Types).",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: {
-                    type: "string",
-                    description: "Path to scan (relative to project root)",
-                },
-            },
-            required: ["path"],
-        },
-    },
-];
-export const securityHandlers = {
-    security_audit_scan: async (args, projectRoot) => {
-        const parsed = SECURITY_AUDIT_ARGS_SCHEMA.safeParse(args ?? {});
-        if (!parsed.success)
-            return { content: [{ type: "text", text: "Invalid path argument." }] };
-        const vulnerabilities = [];
-        const scanRules = [
-            { pattern: /sql`/, message: "Potential Raw SQL usage detected (check Kysely usage)", severity: "HIGH" },
-            { pattern: /(?<!\/\/\s*)console\.log/, message: "console.log found in production code", severity: "LOW" },
-            { pattern: /(password|secret|api_?key)\s*[:=]\s*['"][^'"]+['"]/i, message: "Potential hardcoded secret/password detected", severity: "CRITICAL" },
-            { pattern: /:\s*any(?!\w)/, message: "Usage of 'any' type detected", severity: "MEDIUM" },
-            { pattern: /(?<!\w)eval\s*\(/, message: "Dangerous 'eval()' usage detected", severity: "HIGH" },
-            { pattern: /\.innerHTML\s*=/, message: "Unsafe innerHTML assignment detected (XSS risk)", severity: "MEDIUM" },
-            { pattern: /dangerouslySetInnerHTML/, message: "React dangerouslySetInnerHTML detected", severity: "MEDIUM" },
-            { pattern: /TODO:/, message: "Outstanding TODO item found", severity: "LOW" },
-        ];
-        try {
-            const safeTargetPath = resolveSafePath(projectRoot, parsed.data.path);
-            if (!fs.existsSync(safeTargetPath))
-                return { content: [{ type: "text", text: "Target path not found." }] };
-            const files = collectFilesRecursively(safeTargetPath, new Set(["ts", "tsx"]));
-            for (const rule of scanRules) {
-                const ruleMatches = buildLineMatches(files, (line) => typeof rule.pattern === "string" ? line.includes(rule.pattern) : rule.pattern.test(line), 5, projectRoot);
-                if (ruleMatches.length > 0)
-                    vulnerabilities.push(`[${rule.severity}] ${rule.message}:\n${ruleMatches.join("\n")}`);
-            }
-            const tsProject = new Project({ compilerOptions: { allowJs: true } });
-            tsProject.addSourceFilesAtPaths(path.join(safeTargetPath, "**/*.{ts,tsx}"));
-            for (const sourceFile of tsProject.getSourceFiles()) {
-                const relativePath = path.relative(projectRoot, sourceFile.getFilePath());
-                sourceFile.forEachDescendant((node) => {
-                    if (node.getKindName() === "AnyKeyword") {
-                        vulnerabilities.push(`[MEDIUM] Precise 'any' type detected in AST at ${relativePath}:${node.getStartLineNumber()}`);
-                    }
-                    if (node.getKind() === SyntaxKind.CallExpression) {
-                        const callExp = node.asKind(SyntaxKind.CallExpression);
-                        if (callExp?.getExpression().getText() === "console.log") {
-                            vulnerabilities.push(`[LOW] Production 'console.log' detected in AST at ${relativePath}:${node.getStartLineNumber()}`);
-                        }
-                    }
-                });
-            }
-            return { content: [{ type: "text", text: vulnerabilities.length > 0 ? `### ADVANCED SECURITY AUDIT RESULTS\n\n${Array.from(new Set(vulnerabilities)).join("\n\n")}` : "No security patterns or rule violations detected (Regex & AST verified)." }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Security audit failed." }] };
-        }
-    },
-    analyze_constitution_compliance: async (args, projectRoot) => {
-        const parsed = ANALYZE_CONSTITUTION_COMPLIANCE_ARGS_SCHEMA.safeParse(args ?? {});
-        if (!parsed.success)
-            return { content: [{ type: "text", text: "Invalid path argument." }] };
-        try {
-            const safePath = resolveSafePath(projectRoot, parsed.data.path);
-            const violations = [];
-            const forbiddenLibraries = ["@shadcn", "mui", "@chakra-ui", "antd", "bootstrap", "tailwindcss"];
-            if (fs.existsSync(safePath) && fs.lstatSync(safePath).isDirectory()) {
-                const tsProject = new Project({ compilerOptions: { allowJs: true } });
-                tsProject.addSourceFilesAtPaths(path.join(safePath, "**/*.{ts,tsx,js,jsx}"));
-                for (const sourceFile of tsProject.getSourceFiles()) {
-                    const relativePath = path.relative(projectRoot, sourceFile.getFilePath());
-                    if (relativePath.includes("node_modules") || relativePath.includes("dist"))
-                        continue;
-                    // AST-based Import Check for Zero UI Policy
-                    sourceFile.getImportDeclarations().forEach(imp => {
-                        const moduleValue = imp.getModuleSpecifierValue();
-                        if (forbiddenLibraries.some(lib => moduleValue.includes(lib))) {
-                            violations.push(`${relativePath}: AST Violation - Zero UI Library Policy (imported '${moduleValue}')`);
-                        }
-                    });
-                    // AST-based String ID Check for Branded Types Law
-                    sourceFile.getInterfaces().forEach(iface => {
-                        const idProp = iface.getProperty("id");
-                        if (idProp && idProp.getType().isString() && !idProp.getType().getText().includes("Brand")) {
-                            violations.push(`${relativePath}: AST Violation - Branded Types Law (interface '${iface.getName()}' uses plain string for ID)`);
-                        }
-                    });
-                    const content = sourceFile.getFullText();
-                    if (content.includes("console.log") && !relativePath.includes("cli.js")) {
-                        violations.push(`${relativePath}: Text Violation - Logging Policy (found 'console.log')`);
-                    }
-                    if (content.includes("sql`")) {
-                        violations.push(`${relativePath}: Text Violation - Potential Kysely Standards (found raw 'sql' tag)`);
-                    }
-                }
-            }
-            else if (fs.existsSync(safePath)) {
-                // Fallback for single files
-                const content = fs.readFileSync(safePath, "utf-8");
-                const relativePath = path.relative(projectRoot, safePath);
-                for (const lib of forbiddenLibraries) {
-                    if (content.includes(lib))
-                        violations.push(`${relativePath}: Violation of Zero UI Library Policy (found '${lib}')`);
-                }
-            }
-            return { content: [{ type: "text", text: `### CONSTITUTION COMPLIANCE REPORT\n\n` + (violations.length > 0 ? `⚠️ **VIOLATIONS FOUND:**\n${violations.map(v => `- ${v}`).join("\n")}` : "✅ **ALL SYSTEMS COMPLIANT:** AST and Regex scans passed. No rule violations detected.") }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Constitution compliance check failed." }] };
-        }
-    },
-};

package/framework-mcp/dist/utils.js

@@ -1,121 +0,0 @@
-import path from "path";
-import fs from "fs";
-import { fileURLToPath } from "url";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const getPackageVersion = () => {
-    try {
-        const pkgPath = path.join(__dirname, "../package.json");
-        if (fs.existsSync(pkgPath)) {
-            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-            return pkg.version || "0.7.5";
-        }
-    }
-    catch {
-        // fallback
-    }
-    return "0.6.6";
-};
-export const FRAMEWORK_VERSION = getPackageVersion();
-/**
- * Dynamically detects the framework directory for the current project.
- * Checks in priority order: .enderun → .gemini → .cursor → fallback .gemini
- * This resolves the adapter mismatch bug (KRITIK-1 in v0.7.5 analysis).
- */
-export function getFrameworkDir(projectRoot) {
-    const candidates = [".enderun", ".gemini", ".cursor"];
-    for (const dir of candidates) {
-        const dirPath = path.join(projectRoot, dir);
-        if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
-            // Verify it looks like a framework dir (has PROJECT_MEMORY.md or agents/ dir)
-            const hasMemory = fs.existsSync(path.join(dirPath, "PROJECT_MEMORY.md"));
-            const hasAgents = fs.existsSync(path.join(dirPath, "agents"));
-            if (hasMemory || hasAgents) {
-                return dir;
-            }
-        }
-    }
-    // Ultimate fallback — return first existing dir or .gemini
-    for (const dir of candidates) {
-        if (fs.existsSync(path.join(projectRoot, dir)))
-            return dir;
-    }
-    return ".gemini";
-}
-export function resolveSafePath(projectRoot, targetPath) {
-    const resolved = path.resolve(projectRoot, targetPath);
-    const relative = path.relative(projectRoot, resolved);
-    if (relative.startsWith("..") || path.isAbsolute(relative)) {
-        throw new Error("Path escapes project root.");
-    }
-    return resolved;
-}
-export function collectFilesRecursively(targetPath, extensions) {
-    const results = [];
-    const entries = fs.readdirSync(targetPath, { withFileTypes: true });
-    for (const entry of entries) {
-        const fullPath = path.join(targetPath, entry.name);
-        if (entry.isDirectory()) {
-            if (entry.name === "node_modules" || entry.name === ".git")
-                continue;
-            results.push(...collectFilesRecursively(fullPath, extensions));
-            continue;
-        }
-        const ext = path.extname(entry.name).slice(1).toLowerCase();
-        if (extensions.has(ext))
-            results.push(fullPath);
-    }
-    return results;
-}
-export function buildLineMatches(files, matcher, maxResults, projectRoot) {
-    const matches = [];
-    for (const filePath of files) {
-        if (matches.length >= maxResults)
-            break;
-        const content = fs.readFileSync(filePath, "utf-8");
-        const lines = content.split("\n");
-        for (let i = 0; i < lines.length; i++) {
-            if (matches.length >= maxResults)
-                break;
-            const line = lines[i];
-            if (!matcher(line))
-                continue;
-            const relativePath = path.relative(projectRoot, filePath);
-            matches.push(`${relativePath}:${i + 1}:${line}`);
-        }
-    }
-    return matches;
-}
-export function collectMarkdownArtifacts(projectRoot) {
-    const frameworkDir = getFrameworkDir(projectRoot);
-    const searchPaths = [
-        path.join(projectRoot, "docs"),
-        path.join(projectRoot, frameworkDir, "docs")
-    ];
-    const results = [];
-    for (const docsRoot of searchPaths) {
-        if (fs.existsSync(docsRoot)) {
-            results.push(...collectFilesRecursively(docsRoot, new Set(["md"])).map((filePath) => path.relative(projectRoot, filePath)));
-        }
-    }
-    return Array.from(new Set(results));
-}
-export function replaceSectionContent(markdown, sectionTitle, newBody) {
-    const escaped = sectionTitle.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const sectionRegex = new RegExp(`## ${escaped}[\\s\\S]*?(?=\\n## |$)`);
-    if (!sectionRegex.test(markdown)) {
-        throw new Error(`Section not found: ${sectionTitle}`);
-    }
-    return markdown.replace(sectionRegex, `## ${sectionTitle}\n\n${newBody.trim()}\n`);
-}
-export function prependToSection(markdown, sectionTitle, contentToPrepend) {
-    const escaped = sectionTitle.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const sectionRegex = new RegExp(`(## ${escaped}\\n)([\\s\\S]*?)(?=\\n## |$)`);
-    const match = markdown.match(sectionRegex);
-    if (!match) {
-        throw new Error(`Section not found: ${sectionTitle}`);
-    }
-    const currentBody = match[2].trimStart();
-    const updatedBody = `${contentToPrepend.trim()}\n\n${currentBody}`.trim();
-    return markdown.replace(sectionRegex, `$1\n${updatedBody}\n`);
-}

package/framework-mcp/src/index.ts

@@ -1,49 +0,0 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { allTools, allHandlers } from "./tools/index.js";
-import { FRAMEWORK_VERSION } from "./utils.js";
-
-const server = new Server({
-    name: "ai-enderun-mcp",
-    version: FRAMEWORK_VERSION,
-}, {
-    capabilities: {
-        tools: {},
-    },
-});
-
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return {
-        tools: allTools,
-    };
-});
-
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    const projectRoot = process.cwd();
-    
-    // Handle compatibility for context search
-    let effectiveArgs = args;
-    if (name === "codebase_context_search") {
-        effectiveArgs = { extension: "md", ...(args ?? {}) };
-    }
-
-    const handler = allHandlers[name];
-    if (handler) {
-        return await handler(effectiveArgs, projectRoot);
-    }
-
-    throw new Error(`Tool not found: ${name}`);
-});
-
-async function main() {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error("Framework MCP Server running on stdio");
-}
-
-main().catch((error) => {
-    console.error("Fatal error in main():", error);
-    process.exit(1);
-});

package/framework-mcp/src/schemas.ts

@@ -1,106 +0,0 @@
-import { z } from "zod";
-
-export const SECURITY_AUDIT_ARGS_SCHEMA = z.object({
-    path: z.string().default("."),
-});
-
-export const SEARCH_CODEBASE_ARGS_SCHEMA = z.object({
-    query: z.string().min(1).max(300),
-    extension: z
-        .string()
-        .default("ts")
-        .refine((s) => /^[a-z0-9]+$/i.test(s), { message: "extension must be alphanumeric" }),
-});
-
-export const UPDATE_MEMORY_ARGS_SCHEMA = z.object({
-    section: z.enum(["CURRENT STATUS", "HISTORY", "ACTIVE TASKS"]),
-    content: z.string().min(1),
-});
-
-export const ANALYZE_DEPENDENCIES_ARGS_SCHEMA = z.object({
-    path: z.string().min(1),
-});
-
-export const LOG_AGENT_ACTION_ARGS_SCHEMA = z.object({
-    agent: z.string().min(1),
-    action: z.string().min(1),
-    requestId: z.string().min(1),
-    files: z.array(z.string()).default([]),
-    status: z.enum(["SUCCESS", "FAILURE"]),
-    summary: z.string().min(1),
-    details: z.record(z.string(), z.any()).default({}),
-});
-
-export const SEND_AGENT_MESSAGE_ARGS_SCHEMA = z.object({
-    from: z.string().min(1),
-    to: z.string().min(1),
-    message: z.string().min(1),
-    traceId: z.string().min(1),
-    category: z.enum(["ACTION", "DELEGATION", "INFO", "ALERT"]).default("INFO"),
-    priority: z.enum(["LOW", "MEDIUM", "HIGH", "URGENT"]).default("MEDIUM"),
-});
-
-export const UPDATE_AGENT_MESSAGE_STATUS_ARGS_SCHEMA = z.object({
-    agent: z.string().min(1),
-    traceId: z.string().min(1),
-    newStatus: z.enum(["ACKNOWLEDGED", "COMPLETED", "REJECTED"]),
-});
-
-export const SEARCH_KNOWLEDGE_BASE_ARGS_SCHEMA = z.object({
-    query: z.string().min(1),
-});
-
-export const UPDATE_KNOWLEDGE_BASE_ARGS_SCHEMA = z.object({
-    topic: z.string().min(1),
-    content: z.string().min(1),
-    tags: z.array(z.string().min(1)).default([]),
-});
-
-export const ANALYZE_CONSTITUTION_COMPLIANCE_ARGS_SCHEMA = z.object({
-    path: z.string().min(1),
-});
-
-export const GENERATE_DEPENDENCY_GRAPH_ARGS_SCHEMA = z.object({
-    path: z.string().default("src"),
-    format: z.enum(["mermaid", "json"]).default("mermaid"),
-});
-
-export const READ_AGENT_MESSAGES_ARGS_SCHEMA = z.object({
-    agent: z.string().min(1),
-    traceId: z.string().min(1).optional(),
-});
-
-export const VERIFY_CONTRACT_INTEGRITY_ARGS_SCHEMA = z.object({
-    domain: z.string().min(1),
-});
-
-export const GENERATE_SEMANTIC_COMMIT_MESSAGE_ARGS_SCHEMA = z.object({
-    traceId: z.string().min(1),
-});
-
-export const ANALYZE_CODEBASE_INTELLIGENCE_ARGS_SCHEMA = z.object({
-    path: z.string().default("."),
-});
-
-export const ANALYZE_PROCEDURAL_CONTINUITY_ARGS_SCHEMA = z.object({
-    targetPath: z.string().min(1),
-    referencePath: z.string().min(1),
-});
-
-export const GET_AGENT_INBOX_STATS_ARGS_SCHEMA = z.object({
-    agent: z.string().min(1),
-});
-
-export const GET_KNOWLEDGE_GRAPH_ARGS_SCHEMA = z.object({
-    tag: z.string().optional(),
-});
-
-export const SYNC_CONTRACT_HASH_ARGS_SCHEMA = z.object({
-    force: z.boolean().default(false),
-});
-
-export const VERIFY_FRAMEWORK_HEALTH_ARGS_SCHEMA = z.object({
-    detailed: z.boolean().default(false),
-});
-
-