mcp-ai-agent-guidelines
Version:
A comprehensive Model Context Protocol server providing professional tools, resources, and prompts for implementing AI agent best practices
197 lines • 9.16 kB
JavaScript
// Design Assistant - Main orchestrator/facade for the deterministic design framework
import { z } from "zod";
import { ConfigurationError } from "../shared/errors.js";
import { confirmationModule } from "./confirmation-module.js";
import { constraintManager, DEFAULT_CONSTRAINT_CONFIG, } from "./constraint-manager.js";
import { coverageEnforcer } from "./coverage-enforcer.js";
import { crossSessionConsistencyEnforcer } from "./cross-session-consistency-enforcer.js";
import { methodologySelector } from "./methodology-selector.js";
import { pivotModule } from "./pivot-module.js";
import { additionalOperationsService, artifactGenerationService, consistencyService, phaseManagementService, sessionManagementService, } from "./services/index.js";
const _DesignAssistantRequestSchema = z.object({
action: z.enum([
"start-session",
"advance-phase",
"validate-phase",
"evaluate-pivot",
"generate-strategic-pivot-prompt",
"generate-artifacts",
"enforce-coverage",
"enforce-consistency",
"get-status",
"load-constraints",
"select-methodology",
"enforce-cross-session-consistency",
"generate-enforcement-prompts",
"generate-constraint-documentation",
]),
sessionId: z.string(),
config: z.any().optional(), // DesignSessionConfig
content: z.string().optional(),
phaseId: z.string().optional(),
constraintId: z.string().optional(),
constraintConfig: z.any().optional(),
methodologySignals: z.any().optional(), // MethodologySignals
artifactTypes: z
.array(z.enum(["adr", "specification", "roadmap"]))
.optional(),
includeTemplates: z.boolean().optional(),
includeSpace7Instructions: z.boolean().optional(),
customInstructions: z.array(z.string()).optional(),
metadata: z.record(z.unknown()).optional().default({}),
});
class DesignAssistantImpl {
initialized = false;
async initialize() {
if (this.initialized)
return;
try {
// Load default constraint configuration
await constraintManager.loadConstraintsFromConfig(DEFAULT_CONSTRAINT_CONFIG);
// Initialize sub-modules
await confirmationModule.initialize();
await pivotModule.initialize();
await coverageEnforcer.initialize();
await methodologySelector.initialize();
await crossSessionConsistencyEnforcer.initialize();
this.initialized = true;
}
catch (error) {
throw new ConfigurationError("Failed to initialize Design Assistant", {
originalError: error instanceof Error ? error.message : String(error),
});
}
}
// Backwards-compatible wrappers expected by tests
async createSession(config) {
await this.initialize();
const sessionId = `session-${Date.now()}`;
const resp = await this.processRequest({
action: "start-session",
sessionId,
config: {
sessionId,
context: config.context,
goal: config.goal,
requirements: config.requirements,
constraints: [],
coverageThreshold: 85,
enablePivots: true,
templateRefs: [],
outputFormats: ["markdown"],
metadata: {},
},
});
return { ...resp, sessionId };
}
async getPhaseGuidance(_sessionState, phaseId) {
await this.initialize();
return phaseManagementService.getPhaseGuidance(_sessionState, phaseId);
}
async validateConstraints(_sessionState) {
await this.initialize();
return { passed: true };
}
async generateWorkflow(_sessionState) {
await this.initialize();
return { steps: ["discovery", "requirements", "architecture"] };
}
async processRequest(request) {
await this.initialize();
const { action, sessionId } = request;
try {
switch (action) {
case "start-session":
if (!request.config) {
throw new Error("Configuration is required for start-session action");
}
return sessionManagementService.startDesignSession(sessionId, request.config, request.constraintConfig);
case "advance-phase":
return phaseManagementService.advancePhase(sessionId, request.content, request.phaseId);
case "validate-phase":
if (!request.phaseId || !request.content) {
throw new Error("Phase ID and content are required for validate-phase action");
}
return phaseManagementService.validatePhase(sessionId, request.phaseId, request.content);
case "evaluate-pivot":
if (!request.content) {
throw new Error("Content is required for evaluate-pivot action");
}
return additionalOperationsService.evaluatePivot(sessionId, request.content);
case "generate-strategic-pivot-prompt":
if (!request.content) {
throw new Error("Content is required for generate-strategic-pivot-prompt action");
}
return additionalOperationsService.generateStrategicPivotPrompt(sessionId, request.content, request.includeTemplates, request.includeSpace7Instructions, request.customInstructions);
case "generate-artifacts":
return artifactGenerationService.generateArtifacts(sessionId, request.artifactTypes || ["adr", "specification", "roadmap"]);
case "enforce-coverage":
if (!request.content) {
throw new Error("Content is required for enforce-coverage action");
}
return consistencyService.enforceCoverage(sessionId, request.content);
case "enforce-consistency":
return consistencyService.enforceConsistency(sessionId, request.constraintId, request.phaseId, request.content);
case "get-status":
return sessionManagementService.getSessionStatus(sessionId);
case "load-constraints":
if (!request.constraintConfig) {
throw new Error("Constraint configuration is required for load-constraints action");
}
return additionalOperationsService.loadConstraints(request.constraintConfig);
case "select-methodology":
if (!request.methodologySignals) {
throw new ConfigurationError("Methodology signals are required for select-methodology action", { sessionId, action });
}
return additionalOperationsService.selectMethodology(sessionId, request.methodologySignals);
case "enforce-cross-session-consistency":
return consistencyService.enforceCrossSessionConsistency(sessionId);
case "generate-enforcement-prompts":
return consistencyService.generateEnforcementPrompts(sessionId);
case "generate-constraint-documentation":
return artifactGenerationService.generateConstraintDocumentation(sessionId);
default:
throw new ConfigurationError(`Unknown action: ${action}`, {
action,
sessionId,
});
}
}
catch (error) {
// Use the same error response format as services
return {
success: false,
sessionId,
status: "error",
message: error instanceof Error ? error.message : "Unknown error occurred",
recommendations: ["Check request parameters and try again"],
artifacts: [],
};
}
}
// Utility methods
async getActiveSessions() {
return sessionManagementService.getActiveSessions();
}
async getConstraintSummary() {
await this.initialize();
const constraints = constraintManager.getConstraints();
const mandatory = constraintManager.getMandatoryConstraints();
const categories = [...new Set((constraints || []).map((c) => c.category))];
const thresholds = constraintManager.getCoverageThresholds();
return {
total: constraints.length,
mandatory: mandatory.length,
categories,
thresholds,
};
}
async getPhaseSequence() {
return phaseManagementService.getPhaseSequence();
}
}
// Export singleton instance
export const designAssistant = new DesignAssistantImpl();
// Module Implementation Status Sentinel
export const IMPLEMENTATION_STATUS = "IMPLEMENTED";
//# sourceMappingURL=design-assistant.js.map