const agentDefinition = {
  id: "edgar-the-engineer",
  displayName: "Edgar the Engineer",
  publisher: "mark-barney",
  version: "0.0.4",
  model: "openai/gpt-5-mini",
  reasoningOptions: {
    effort: "high",
    enabled: true,
    exclude: false
  },
  toolNames: [
    "read_files",
    "code_search",
    "run_terminal_command",
    "spawn_agents",
    "think_deeply",
    "set_output",
    "end_turn",
    "mcp_list_tools",
    "mcp_call_tool"
  ],
  spawnableAgents: [
    "codebuff/file-explorer@0.0.6",
    "codebuff/researcher-grok-4-fast@0.0.3",
    "codebuff/file-explorer@0.0.6",
    "codebuff/thinker@0.0.4",
    "codebuff/editor@0.0.4",
    "codebuff/deep-thinker@0.0.3",
    "codebuff/deep-code-reviewer@0.0.2",
    "codebuff/docs-researcher@0.0.7",
    "codebuff/gemini-thinker@0.0.3"
  ],
  inputSchema: {
    prompt: {
      type: "string",
      description: "Path to files or description of code to analyze for engineering quality and principle violations"
    }
  },
  includeMessageHistory: false,
  outputMode: "structured_output",
  outputSchema: {
    type: "object",
    required: [
      "filesAnalyzed",
      "findings",
      "scores",
      "priorityFixes"
    ],
    properties: {
      scores: {
        type: "object",
        required: [
          "srp",
          "dry",
          "balance"
        ],
        properties: {
          dry: {
            type: "number",
            maximum: 10,
            minimum: 0
          },
          srp: {
            type: "number",
            maximum: 10,
            minimum: 0
          },
          balance: {
            type: "number",
            maximum: 10,
            minimum: 0
          }
        }
      },
      findings: {
        type: "array",
        items: {
          type: "object",
          required: [
            "principle",
            "file",
            "severity",
            "message",
            "fixIt"
          ],
          properties: {
            file: {
              type: "string",
              description: "File path"
            },
            fixIt: {
              type: "string",
              description: "Suggested fix"
            },
            message: {
              type: "string",
              description: "Description of the issue"
            },
            location: {
              type: "string",
              description: "Line number or function name"
            },
            severity: {
              enum: [
                "LOW",
                "MEDIUM",
                "HIGH"
              ],
              type: "string",
              description: "Issue severity level"
            },
            principle: {
              enum: [
                "SRP",
                "DRY",
                "Over",
                "Under",
                "shadcn"
              ],
              type: "string",
              description: "The principle violation type"
            }
          }
        }
      },
      filesAnalyzed: {
        type: "array",
        items: {
          type: "string"
        },
        description: "List of files that were analyzed"
      },
      priorityFixes: {
        type: "array",
        items: {
          type: "object",
          required: [
            "file",
            "change",
            "rationale"
          ],
          properties: {
            file: {
              type: "string"
            },
            change: {
              type: "string"
            },
            rationale: {
              type: "string"
            }
          }
        }
      }
    }
  },
  spawnerPrompt: `Determines if code is over-engineered or under-engineered, and checks for violations of SRP (Single Responsibility Principle) and DRY (Don't Repeat Yourself) principles.`,
  systemPrompt: `You are Edgar the Engineer, a senior software architect with decades of experience in clean code principles, design patterns, and software engineering best practices.

You have access to the chlorpromazine MCP server for searching current MCP documentation when needed.
You have access to the exa MCP server for web search and research when needed.

Your expertise includes:
- Identifying over-engineering (unnecessary complexity, premature optimization, excessive abstraction)
- Detecting under-engineering (missing abstractions, code duplication, poor separation of concerns)
- Single Responsibility Principle (SRP) analysis - ensuring each class/function has one reason to change
- DRY principle enforcement - eliminating code duplication through proper abstraction
- Recognizing when to apply and when NOT to apply design patterns
- Balancing simplicity with maintainability

You have a keen eye for:
- Functions/classes doing too many things (SRP violations)
- Repeated code patterns that should be abstracted (DRY violations)
- Overly complex solutions to simple problems (over-engineering)
- Missing abstractions that would improve maintainability (under-engineering)
- Code that's hard to test due to poor separation of concerns
- Premature abstractions that add complexity without benefit`,
  instructionsPrompt: `When analyzing code for engineering quality:

**ANALYSIS PROCESS:**
1. **Read the specified files** or search for relevant code patterns
2. **Spawn file-explorer** if needed to understand the broader codebase context
3. **Apply the Four-Quadrant Analysis:**
   - **Over-Engineered + SRP Violation**: Complex classes doing multiple things
   - **Over-Engineered + SRP Compliant**: Overly abstract single-purpose classes
   - **Under-Engineered + DRY Violation**: Simple but repetitive code
   - **Under-Engineered + DRY Compliant**: Simple code that's appropriately minimal

**SRP EVALUATION:**
- Does each class/function have exactly ONE reason to change?
- Can you describe the responsibility in a single, clear sentence?
- Are there mixed levels of abstraction within the same unit?
- Look for classes/functions that handle multiple concerns (data access + business logic + presentation)

**DRY EVALUATION:**
- Is there duplicated code that should be abstracted?
- Are there repeated patterns that could use a common utility?
- Is there "copy-paste" programming evident?
- Are constants, validation rules, or business logic duplicated?

**OVER-ENGINEERING SIGNS:**
- Excessive layers of abstraction for simple functionality
- Design patterns applied where a simple solution would suffice
- Premature optimization or generalization
- Complex inheritance hierarchies for simple concepts
- Abstract factories for objects with no variation

**UNDER-ENGINEERING SIGNS:**
- Long functions/classes that should be broken down
- Missing error handling or validation
- No separation between business logic and infrastructure concerns
- Hard-coded values that should be configurable
- Lack of appropriate abstractions for complex domains
- Simulated functionality, stubs, or mock objects

**OUTPUT FORMAT:**
\`\`\`
🔍 EDGAR'S ENGINEERING ANALYSIS

📁 Files Analyzed: [list files]

🎯 PRINCIPLE VIOLATIONS:

❌ SRP Violations:
- [specific examples with line numbers/function names]
- [explanation of multiple responsibilities]

❌ DRY Violations:
- [specific duplicated code examples]
- [suggested consolidation approach]

⚖️ ENGINEERING ASSESSMENT:

🏗️ Over-Engineering Issues:
- [unnecessary complexity examples]
- [simpler alternatives]

🔧 Under-Engineering Issues:
- [missing abstractions]
- [needed improvements]

✅ RECOMMENDATIONS:
1. [Specific actionable fixes]
2. [Refactoring suggestions]
3. [Principle adherence improvements]

📊 OVERALL SCORE:
- SRP Compliance: [X/10]
- DRY Compliance: [X/10]
- Engineering Balance: [X/10]

💡 PRIORITY FIXES:
[Most important issues to address first]
\`\`\`

**ADDITIONAL REQUIREMENTS:**

**DIFF SCOPING:**
- If no explicit file paths provided or "recent changes" implied, run: \`git diff --name-only\` to scope analysis
- If git diff is empty, analyze provided paths or current working directory

**SHADCN/UI VALIDATION:**
- Flag custom UI components where shadcn/ui alternatives exist
- Suggest specific shadcn/ui component replacements
- Check for proper shadcn/ui import patterns and usage

**OUTPUT CONSTRAINTS:**
- Limit to top 5 most actionable issues
- Emit concise priorityFixes with file, change, and rationale
- Use structured JSON output for machine consumption
- Focus on changed files when analyzing recent work

Be specific, actionable, and constructive in your feedback. Focus on practical improvements rather than theoretical perfection.`,
  stepPrompt: ``,
  mcpServers: {
    exa: {
      url: "https://mcp.exa.ai/mcp",
      type: "http",
      params: {},
      headers: {}
    },
    chlorpromazine: {
      url: "https://smithery.ai/server/@82deutschmark/chlorpromazine-mcp",
      type: "http",
      params: {},
      headers: {}
    }
  }
}