@identikey/coding-mcp 2.0.1

package/build/tools/ask.js

@@ -0,0 +1,139 @@
+import { z } from "zod";
+import { classifyQuery, explainRouting } from "../personas/router.js";
+import { PersonaRegistry } from "../personas/types.js";
+import { callAIWithPersona } from "../common/personaClient.js";
+/**
+ * Ask tool - Smart routing to the best persona based on query analysis
+ * Primary UX for natural language interaction with personas
+ */
+export const askToolName = "ask";
+export const askToolDescription = "Ask a question naturally and get routed to the best expert persona automatically. You can also address a persona directly, e.g., 'ask xavier: <your question>' or 'charles: <your question>' to force that persona.";
+export const AskToolSchema = z.object({
+    persona_id: z
+        .union([z.literal("auto"), z.string()])
+        .optional()
+        .default("auto")
+        .describe("Persona to use: 'auto' (default) routes to best expert, or a specific id like 'charles', 'ada', 'xavier'"),
+    query: z
+        .string()
+        .min(1, "Query is required")
+        .describe("Your question or request"),
+    context: z
+        .string()
+        .optional()
+        .describe("Additional code or context for analysis"),
+    hint: z
+        .string()
+        .optional()
+        .describe("Optional hint for routing (e.g., 'architecture', 'security')"),
+    explain_routing: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Show which persona was selected and why"),
+    reasoning_effort: z
+        .union([z.literal("low"), z.literal("medium"), z.literal("high")])
+        .optional()
+        .describe("How thoroughly to think about the answer"),
+    provider: z
+        .union([z.literal("xai"), z.literal("openai")])
+        .optional()
+        .describe("Optional provider override; defaults to persona preference or heuristic"),
+});
+export async function runAskTool(args) {
+    const { persona_id = "auto", query, context = "", hint, explain_routing, reasoning_effort, provider, } = args;
+    // Natural-language persona addressing (e.g., "ask xavier:", "xavier:")
+    let cleanedQuery = query;
+    let nlPersonaId;
+    const aliases = {
+        charles: ["charles", "charlie"],
+        ada: ["ada"],
+        xavier: ["xavier", "x"],
+    };
+    const lowered = query.trim().toLowerCase();
+    for (const [pid, names] of Object.entries(aliases)) {
+        for (const name of names) {
+            const patterns = [
+                new RegExp(`^ask\\s+${name}[:,-]\\s*`, "i"),
+                new RegExp(`^ask\\s+${name}\\s+for\\s+`, "i"),
+                new RegExp(`^${name}[:,-]\\s*`, "i"),
+                new RegExp(`^${name}\\s+for\\s+`, "i"),
+            ];
+            if (patterns.some((p) => p.test(lowered))) {
+                nlPersonaId = pid;
+                cleanedQuery = query
+                    .replace(patterns[0], "")
+                    .replace(patterns[1], "")
+                    .replace(patterns[2], "")
+                    .replace(patterns[3], "")
+                    .trim();
+                break;
+            }
+        }
+        if (nlPersonaId)
+            break;
+    }
+    // Determine persona: explicit override or classification
+    let selectedPersonaId = nlPersonaId || (persona_id === "auto" ? undefined : persona_id);
+    let classification;
+    if (!selectedPersonaId) {
+        classification = classifyQuery(cleanedQuery, hint);
+        selectedPersonaId = classification.primaryPersona;
+    }
+    // Get the selected persona
+    const persona = PersonaRegistry.get(selectedPersonaId);
+    if (!persona) {
+        // Shouldn't happen but handle gracefully
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "No suitable expert found. Please use the 'discover' tool to see available personas.",
+                },
+            ],
+        };
+    }
+    try {
+        // Build response with optional routing explanation
+        let response = "";
+        if (explain_routing) {
+            const explanation = classification
+                ? explainRouting(classification)
+                : `Using your selected expert: ${persona.name}.`;
+            response += `*${explanation}*\n\n---\n\n`;
+        }
+        // Simple system prompt for natural conversation
+        const systemPrompt = `You are having a natural conversation with the user, providing expert guidance based on your knowledge and experience.
+    
+Answer their question directly and helpfully while maintaining your personality.`;
+        // Call the persona
+        const personaResponse = await callAIWithPersona({
+            systemPrompt,
+            task: cleanedQuery,
+            code: context,
+            analysisType: "advice", // Default to advice for ask tool
+            reasoningEffort: (reasoning_effort || "medium"),
+            personaId: persona.id,
+            providerOverride: provider,
+        });
+        response += personaResponse;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: response,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error consulting ${persona.name}: ${error.message || error}`,
+                },
+            ],
+        };
+    }
+}

package/build/tools/codeReview.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+/**
+ * CodeReview tool
+ *   - Takes in a file path and runs "git diff main -- <filePath>"
+ *   - Returns the diff along with instructions to review and fix issues
+ */
+export declare const codeReviewToolName = "code-review";
+export declare const codeReviewToolDescription = "Run a git diff against main on a specified file and provide instructions to review/fix issues.";
+export declare const CodeReviewToolSchema: z.ZodObject<{
+    folderPath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    folderPath: string;
+}, {
+    folderPath: string;
+}>;
+export declare function runCodeReviewTool(args: z.infer<typeof CodeReviewToolSchema>): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+//# sourceMappingURL=codeReview.d.ts.map

package/build/tools/codeReview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeReview.d.ts","sourceRoot":"","sources":["../../src/tools/codeReview.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;GAIG;AAEH,eAAO,MAAM,kBAAkB,gBAAgB,CAAC;AAChD,eAAO,MAAM,yBAAyB,mGAC4D,CAAC;AAEnG,eAAO,MAAM,oBAAoB;;;;;;EAE/B,CAAC;AAEH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC;;;;;GA2B3C"}

package/build/tools/codeReview.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { execSync } from "child_process";
+/**
+ * CodeReview tool
+ *   - Takes in a file path and runs "git diff main -- <filePath>"
+ *   - Returns the diff along with instructions to review and fix issues
+ */
+export const codeReviewToolName = "code-review";
+export const codeReviewToolDescription = "Run a git diff against main on a specified file and provide instructions to review/fix issues.";
+export const CodeReviewToolSchema = z.object({
+    folderPath: z.string().min(1, "A folder path is required."),
+});
+export async function runCodeReviewTool(args) {
+    const { folderPath } = args;
+    let diffOutput = "";
+    try {
+        diffOutput = execSync(`git -C "${folderPath}" diff`, {
+            encoding: "utf-8",
+        });
+    }
+    catch (error) {
+        // If there's an error (e.g., no git repo, or the file doesn't exist), include it in the response.
+        diffOutput = `Error running git diff: ${error}`;
+    }
+    const instructions = "Review this diff for any obvious issues. Fix them if found, then finalize the changes.";
+    const message = `Git Diff Output:\n${diffOutput}\n\nInstructions:\n${instructions}`;
+    return {
+        content: [
+            {
+                type: "text",
+                text: message,
+            },
+        ],
+    };
+}

package/build/tools/codeadvice.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+/**
+ * CodeAdvice tool
+ *   - Calls an AI model (xAI Grok or OpenAI GPT-5) to provide quick, focused coding guidance
+ *   - Input: 'task' (description of the problem), 'code' (relevant code snippet)
+ *   - Provides immediate, actionable advice for specific coding problems
+ */
+export declare const codeAdviceToolName = "code-advice";
+export declare const codeAdviceToolDescription = "Provides quick, focused coding guidance and immediate solutions for specific problems.";
+export declare const CodeAdviceToolSchema: z.ZodObject<{
+    task: z.ZodString;
+    code: z.ZodString;
+    reasoning_effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    task: string;
+    reasoning_effort?: "low" | "medium" | "high" | undefined;
+}, {
+    code: string;
+    task: string;
+    reasoning_effort?: "low" | "medium" | "high" | undefined;
+}>;
+export declare function runCodeAdviceTool(args: z.infer<typeof CodeAdviceToolSchema>): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+//# sourceMappingURL=codeadvice.d.ts.map

package/build/tools/codeadvice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeadvice.d.ts","sourceRoot":"","sources":["../../src/tools/codeadvice.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB;;;;;GAKG;AAEH,eAAO,MAAM,kBAAkB,gBAAgB,CAAC;AAChD,eAAO,MAAM,yBAAyB,2FACoD,CAAC;AAE3F,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAS/B,CAAC;AAEH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC;;;;;GAsC3C"}

package/build/tools/codeadvice.js

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import { callAIProvider } from "../common/apiClient.js";
+import { chooseProvider, } from "../common/providerConfig.js";
+import { CODEADVICE_SYSTEM_PROMPT } from "../prompts/codeadvicePrompts.js";
+/**
+ * CodeAdvice tool
+ *   - Calls an AI model (xAI Grok or OpenAI GPT-5) to provide quick, focused coding guidance
+ *   - Input: 'task' (description of the problem), 'code' (relevant code snippet)
+ *   - Provides immediate, actionable advice for specific coding problems
+ */
+export const codeAdviceToolName = "code-advice";
+export const codeAdviceToolDescription = "Provides quick, focused coding guidance and immediate solutions for specific problems.";
+export const CodeAdviceToolSchema = z.object({
+    task: z.string().min(1, "Task description is required."),
+    code: z.string().min(1, "Code string is required."),
+    reasoning_effort: z
+        .enum(["low", "medium", "high"])
+        .optional()
+        .describe("How hard the model should think (low/medium/high). Defaults to medium for quick advice."),
+});
+export async function runCodeAdviceTool(args) {
+    const { task, code, reasoning_effort = "medium" } = args;
+    try {
+        const selectedProvider = chooseProvider({
+            analysisType: "advice",
+            reasoningEffort: reasoning_effort,
+            textHint: task,
+        });
+        const result = await callAIProvider({
+            systemPrompt: CODEADVICE_SYSTEM_PROMPT,
+            task,
+            code,
+            analysisType: "advice",
+            reasoningEffort: reasoning_effort,
+            provider: selectedProvider,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `CodeAdvice Error: ${error.message || error}`,
+                },
+            ],
+        };
+    }
+}

package/build/tools/discover.d.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+/**
+ * Discover tool - List and explore available personas
+ * Helps users understand what personas are available and their specialties
+ */
+export declare const discoverToolName = "discover";
+export declare const discoverToolDescription = "Discover available expert personas and their specialties";
+export declare const DiscoverToolSchema: z.ZodObject<{
+    category: z.ZodDefault<z.ZodOptional<z.ZodEnum<["architecture", "algorithms", "security", "frontend", "backend", "data", "all"]>>>;
+    verbose: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    category: "data" | "architecture" | "algorithms" | "frontend" | "backend" | "security" | "all";
+    verbose: boolean;
+}, {
+    category?: "data" | "architecture" | "algorithms" | "frontend" | "backend" | "security" | "all" | undefined;
+    verbose?: boolean | undefined;
+}>;
+export declare function runDiscoverTool(args: z.infer<typeof DiscoverToolSchema>): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+//# sourceMappingURL=discover.d.ts.map

package/build/tools/discover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discover.d.ts","sourceRoot":"","sources":["../../src/tools/discover.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;GAGG;AAEH,eAAO,MAAM,gBAAgB,aAAa,CAAC;AAC3C,eAAO,MAAM,uBAAuB,6DACwB,CAAC;AAE7D,eAAO,MAAM,kBAAkB;;;;;;;;;EAoB7B,CAAC;AAuIH,wBAAsB,eAAe,CACnC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC;;;;;GAsGzC"}

package/build/tools/discover.js

@@ -0,0 +1,220 @@
+import { z } from "zod";
+import { PersonaRegistry } from "../personas/types.js";
+/**
+ * Discover tool - List and explore available personas
+ * Helps users understand what personas are available and their specialties
+ */
+export const discoverToolName = "discover";
+export const discoverToolDescription = "Discover available expert personas and their specialties";
+export const DiscoverToolSchema = z.object({
+    category: z
+        .enum([
+        "architecture",
+        "algorithms",
+        "security",
+        "frontend",
+        "backend",
+        "data",
+        "all",
+    ])
+        .optional()
+        .default("all")
+        .describe("Filter personas by category"),
+    verbose: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Show detailed information including example queries"),
+});
+/**
+ * Get example queries for each persona
+ */
+function getExampleQueries(personaId) {
+    const examples = {
+        charles: [
+            "How should I structure my microservices architecture?",
+            "What's the best pattern for this use case?",
+            "Review my system design for scalability",
+            "How do I reduce coupling between these modules?",
+            "What's causing this technical debt?",
+        ],
+        ada: [
+            "How can I optimize this algorithm?",
+            "What's the time complexity of this function?",
+            "Which data structure should I use here?",
+            "How do I implement dynamic programming for this?",
+            "Profile this code for performance bottlenecks",
+        ],
+        atlas: [
+            "Sketch an OpenAPI for this service and a zero-downtime migration plan",
+            "Design pagination and idempotency for this endpoint",
+            "Model these entities and relationships for scalability",
+            "Propose a contract test suite for backward compatibility",
+            "Eliminate N+1 and add caching without breaking consistency",
+        ],
+        hermes: [
+            "Draft a GitHub Actions pipeline with build/test/deploy and canary",
+            "Add OpenTelemetry and SLOs for this service",
+            "Create Terraform for a minimal prod-ready stack",
+            "Propose a rollback plan and health gates for deploys",
+            "Harden the supply chain with SBOM and signing",
+        ],
+        sentinel: [
+            "Threat model this API and propose cheapest effective controls",
+            "Design OAuth/OIDC login with short-lived tokens and rotation",
+            "Lock down secrets and encrypt data at rest and in transit",
+            "Add rate limits and CSP to prevent abuse",
+            "Write policy-as-code tests for authZ rules",
+        ],
+        iris: [
+            "Design a minimal component API for this flow using a design system",
+            "Make this page meet WCAG 2.2 AA; list fixes",
+            "Improve Core Web Vitals with code-splitting and image optimization",
+            "Add Playwright and axe checks for this form",
+            "Propose DS tokens and a Storybook for reuse",
+        ],
+        "security-expert": [
+            "Is this authentication flow secure?",
+            "How do I prevent SQL injection here?",
+            "Review this code for OWASP vulnerabilities",
+            "What's the best way to store sensitive data?",
+            "How should I implement rate limiting?",
+        ],
+        "frontend-expert": [
+            "How do I structure this React component?",
+            "What's the best state management approach?",
+            "How do I make this UI more accessible?",
+            "Optimize this for mobile performance",
+            "Should I use CSS modules or styled-components?",
+        ],
+        "backend-expert": [
+            "How should I design this REST API?",
+            "What's the best database schema for this?",
+            "How do I handle this at scale?",
+            "Should I use a message queue here?",
+            "How do I implement caching effectively?",
+        ],
+    };
+    return (examples[personaId] || [
+        "Help me understand this code",
+        "What's the best approach for this problem?",
+        "Review this implementation",
+    ]);
+}
+/**
+ * Get category for a persona based on their expertise
+ */
+function getPersonaCategory(persona) {
+    const expertiseStr = persona.traits?.expertise?.join(" ").toLowerCase() || "";
+    if (expertiseStr.includes("architecture") ||
+        expertiseStr.includes("system design")) {
+        return "architecture";
+    }
+    if (expertiseStr.includes("algorithm") ||
+        expertiseStr.includes("optimization")) {
+        return "algorithms";
+    }
+    if (expertiseStr.includes("security") ||
+        expertiseStr.includes("authentication")) {
+        return "security";
+    }
+    if (expertiseStr.includes("frontend") ||
+        expertiseStr.includes("react") ||
+        expertiseStr.includes("ui")) {
+        return "frontend";
+    }
+    if (expertiseStr.includes("backend") ||
+        expertiseStr.includes("api") ||
+        expertiseStr.includes("database")) {
+        return "backend";
+    }
+    if (expertiseStr.includes("data") || expertiseStr.includes("analytics")) {
+        return "data";
+    }
+    return "general";
+}
+export async function runDiscoverTool(args) {
+    const { category, verbose } = args;
+    // Get all registered personas
+    const allPersonas = PersonaRegistry.list();
+    // Filter by category if specified
+    const personas = category === "all"
+        ? allPersonas
+        : allPersonas.filter((p) => getPersonaCategory(p) === category);
+    if (personas.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: category === "all"
+                        ? "No personas are currently registered. Please check your configuration."
+                        : `No personas found in category: ${category}`,
+                },
+            ],
+        };
+    }
+    // Build the response
+    let response = `# Available Expert Personas\n\n`;
+    if (category !== "all") {
+        response += `*Filtered by category: ${category}*\n\n`;
+    }
+    for (const persona of personas) {
+        const info = {
+            id: persona.id,
+            name: persona.name,
+            description: persona.description,
+            expertise: persona.traits.expertise || [],
+        };
+        response += `## ${info.name} (\`${info.id}\`)\n`;
+        response += `${info.description}\n\n`;
+        if (info.expertise.length > 0) {
+            response += `**Expertise:**\n`;
+            info.expertise.forEach((skill) => {
+                response += `- ${skill}\n`;
+            });
+            response += `\n`;
+        }
+        if (verbose) {
+            // Add personality info
+            if (persona.traits.personality) {
+                response += `**Personality:** ${persona.traits.personality}\n\n`;
+            }
+            // Add example queries
+            const examples = getExampleQueries(persona.id);
+            response += `**Example Queries:**\n`;
+            examples.forEach((example) => {
+                response += `- "${example}"\n`;
+            });
+            response += `\n`;
+            // Add communication style
+            const style = persona.traits.communicationStyle;
+            if (style) {
+                response += `**Communication Style:**\n`;
+                response += `- Formality: ${style.formality}\n`;
+                response += `- Humor: ${style.humor}\n`;
+                response += `- Tone: ${style.tone?.join(", ") || "balanced"}\n`;
+                response += `\n`;
+            }
+        }
+        response += `---\n\n`;
+    }
+    // Add usage instructions
+    response += `## How to Use\n\n`;
+    response += `1. **Natural Language** (Recommended):\n`;
+    response += `   Use the \`ask\` tool and your question will be automatically routed to the best expert.\n`;
+    response += `   Example: \`ask "How should I structure my React app?"\`\n\n`;
+    response += `2. **Direct Access**:\n`;
+    response += `   Use the \`persona\` tool with a specific persona ID for precise control.\n`;
+    response += `   Example: \`persona "charles" "Review this architecture"\`\n\n`;
+    if (!verbose) {
+        response += `*Tip: Use \`verbose: true\` to see example queries and detailed persona information.*\n`;
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: response,
+            },
+        ],
+    };
+}

package/build/tools/persona.d.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+/**
+ * Persona tool - Direct interaction with registered personas
+ * Allows calling any registered persona for advice, analysis, or conversation
+ */
+export declare const personaToolName = "persona";
+export declare const personaToolDescription = "Chat with a specific persona for specialized advice and analysis with personality";
+export declare const PersonaToolSchema: z.ZodObject<{
+    persona_id: z.ZodString;
+    query: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    analysis_type: z.ZodDefault<z.ZodOptional<z.ZodEnum<["comprehensive", "advice", "research", "review"]>>>;
+    reasoning_effort: z.ZodDefault<z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>>;
+    tone_style: z.ZodOptional<z.ZodEnum<["concise", "detailed", "humorous", "straight"]>>;
+    output_format: z.ZodOptional<z.ZodEnum<["tldr", "detailed", "dual"]>>;
+    audience_level: z.ZodOptional<z.ZodEnum<["beginner", "intermediate", "expert", "auto"]>>;
+    include_diagrams: z.ZodOptional<z.ZodBoolean>;
+    user_constraints: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    reasoning_effort: "low" | "medium" | "high";
+    query: string;
+    persona_id: string;
+    analysis_type: "comprehensive" | "advice" | "research" | "review";
+    context?: string | undefined;
+    tone_style?: "concise" | "detailed" | "humorous" | "straight" | undefined;
+    output_format?: "detailed" | "tldr" | "dual" | undefined;
+    audience_level?: "beginner" | "intermediate" | "expert" | "auto" | undefined;
+    include_diagrams?: boolean | undefined;
+    user_constraints?: string | undefined;
+}, {
+    query: string;
+    persona_id: string;
+    context?: string | undefined;
+    reasoning_effort?: "low" | "medium" | "high" | undefined;
+    analysis_type?: "comprehensive" | "advice" | "research" | "review" | undefined;
+    tone_style?: "concise" | "detailed" | "humorous" | "straight" | undefined;
+    output_format?: "detailed" | "tldr" | "dual" | undefined;
+    audience_level?: "beginner" | "intermediate" | "expert" | "auto" | undefined;
+    include_diagrams?: boolean | undefined;
+    user_constraints?: string | undefined;
+}>;
+export declare function runPersonaTool(args: z.infer<typeof PersonaToolSchema>): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+//# sourceMappingURL=persona.d.ts.map

package/build/tools/persona.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persona.d.ts","sourceRoot":"","sources":["../../src/tools/persona.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;;GAGG;AAEH,eAAO,MAAM,eAAe,YAAY,CAAC;AACzC,eAAO,MAAM,sBAAsB,sFACkD,CAAC;AAEtF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyD5B,CAAC;AAEH,wBAAsB,cAAc,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC;;;;;GAuE3E"}