Add a new checklist tool for operational readiness

Author: dbravender

README.md

@@ -5,6 +5,7 @@
 - `consult`: Push back on new features with structured questions before any code gets written
 - `stats`: Show complexity scores so users can weigh changes against future maintenance costs
 - `deps`: Know what's already in your project before adding more
+- `checklist`: Evaluate operational readiness before calling a project "done"
 
 In a Calvin and Hobbes strip, Calvin's mom tells him to make his bed. Rather than just do it, he spends the entire day building a robot to make the bed for him. The robot doesn't work, the bed never gets made, and Calvin is more exhausted than if he'd just done it himself.
 
@@ -54,6 +55,21 @@ mtb pushes back — and rightly so. Before writing any code, the agent presents
 
 These aren't meant to block you — they're meant to make sure you're building the right thing.
 
+### `checklist`
+
+Evaluate a project's operational readiness. After shipping code, use this to check whether CI, monitoring, on-call, security, deployment, and documentation concerns have been addressed.
+
+**Parameters:**
+- `project` - description of the project being evaluated
+
+The checklist covers:
+1. **Automated tests / CI** — regression prevention and standards enforcement
+2. **Monitoring** — health checks, metrics, and alerts
+3. **On-call coverage / SLAs** — response time expectations and escalation
+4. **Security audit / automated scans** — vulnerability detection and isolation
+5. **Deployment pipeline / CD** — promotion to test and production environments
+6. **Documentation / runbooks** — onboarding, extension, and operational procedures
+
 ### `stats`
 
 Analyzes code in a directory using [scc](https://github.com/boyter/scc). Returns lines of code, comments, blanks, complexity, and COCOMO cost estimates per language.

internal/tools/checklist.go

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: MIT
+
+package tools
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+)
+
+type ChecklistInput struct {
+	Project string `json:"project" jsonschema:"description of the project being evaluated"`
+}
+
+type ChecklistItem struct {
+	Category    string `json:"category"`
+	Question    string `json:"question"`
+	Description string `json:"description"`
+}
+
+type ChecklistOutput struct {
+	Items    []ChecklistItem `json:"items"`
+	Guidance string          `json:"guidance"`
+}
+
+func HandleChecklist(ctx context.Context, req *mcp.CallToolRequest, input ChecklistInput) (*mcp.CallToolResult, ChecklistOutput, error) {
+	if input.Project == "" {
+		return ErrResult[ChecklistOutput]("project is required")
+	}
+
+	items := []ChecklistItem{
+		{
+			Category:    "Automated tests / CI",
+			Question:    "When new features are added or new bugs are fixed is there a way to prevent regressions?",
+			Description: "Are standards enforced when code is checked in?",
+		},
+		{
+			Category:    "Monitoring",
+			Question:    "How can we know if this project is working as expected?",
+			Description: "Are there health checks, metrics, or alerts that tell you when something is wrong before users report it?",
+		},
+		{
+			Category:    "On-call coverage / SLAs",
+			Question:    "When it stops working do we need to immediately notify someone to get it fixed?",
+			Description: "Is there an on-call rotation or SLA that defines response time expectations?",
+		},
+		{
+			Category:    "Security audit / automated scans",
+			Question:    "When a vulnerability is discovered in this tool or a dependency how can we know?",
+			Description: "Necessity depends on how sensitive the information in this project is and what a compromise could mean — is this project isolated from other projects?",
+		},
+		{
+			Category:    "Deployment pipeline / CD",
+			Question:    "How much work is it to promote these changes to a test or production environment?",
+			Description: "Is there an automated pipeline, or does deployment require manual steps that could be error-prone?",
+		},
+		{
+			Category:    "Documentation / runbooks",
+			Question:    "Can others who use this project quickly learn how it works and how to extend it and maintain it?",
+			Description: "Are there runbooks for common operational tasks like deployments, rollbacks, and incident response?",
+		},
+	}
+
+	guidance := fmt.Sprintf("IMPORTANT: Present each checklist item below to the user for project %q and wait for their answers. "+
+		"Do NOT skip items or assume answers. The goal is to identify operational gaps before they become incidents. "+
+		"For each item, ask the user whether it is addressed, partially addressed, or not addressed, "+
+		"and discuss what concrete next steps would close the gap.", input.Project)
+
+	output := ChecklistOutput{
+		Items:    items,
+		Guidance: guidance,
+	}
+
+	summary := fmt.Sprintf("Operational readiness checklist for: %q\nGenerated %d items to evaluate.", input.Project, len(items))
+
+	return &mcp.CallToolResult{
+		Content: []mcp.Content{&mcp.TextContent{Text: summary}},
+	}, output, nil
+}

internal/tools/checklist_test.go

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+
+package tools
+
+import (
+	"context"
+	"testing"
+
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+)
+
+func TestHandleChecklist_EmptyProject(t *testing.T) {
+	result, _, err := HandleChecklist(context.Background(), &mcp.CallToolRequest{}, ChecklistInput{})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if result == nil || !result.IsError {
+		t.Fatal("expected error result for empty project")
+	}
+}
+
+func TestHandleChecklist_ValidProject(t *testing.T) {
+	_, output, err := HandleChecklist(context.Background(), &mcp.CallToolRequest{}, ChecklistInput{
+		Project: "internal billing service",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if len(output.Items) != 6 {
+		t.Fatalf("expected 6 checklist items, got %d", len(output.Items))
+	}
+	if output.Guidance == "" {
+		t.Fatal("expected guidance to be non-empty")
+	}
+}
+
+func TestHandleChecklist_ItemStructure(t *testing.T) {
+	_, output, err := HandleChecklist(context.Background(), &mcp.CallToolRequest{}, ChecklistInput{
+		Project: "payment gateway integration",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	for i, item := range output.Items {
+		if item.Category == "" {
+			t.Errorf("item %d: expected non-empty category", i)
+		}
+		if item.Question == "" {
+			t.Errorf("item %d: expected non-empty question", i)
+		}
+		if item.Description == "" {
+			t.Errorf("item %d: expected non-empty description", i)
+		}
+	}
+}

main.go

@@ -44,6 +44,11 @@ func main() {
 		Description: "Get a structured consultation before implementing a new feature or adding a dependency. Use this BEFORE writing any new feature code. Takes a problem description, scans the project for relevant existing dependencies, and returns a set of questions the agent MUST present to the user before proceeding. IMPORTANT: When a user asks you to build something non-trivial, call consult first. Present each returned question to the user and wait for their answers. Do NOT skip questions or proceed until the user has considered the tradeoffs.",
 	}, tools.HandleConsult)
 
+	mcp.AddTool(server, &mcp.Tool{
+		Name:        "checklist",
+		Description: "Evaluate a project's operational readiness. Use this before shipping code to check whether CI, monitoring, on-call, security, deployment, and documentation concerns are necessary and have been addressed. Returns checklist items the agent MUST present to the user. IMPORTANT: Present each item and wait for the user's answer before proceeding.",
+	}, tools.HandleChecklist)
+
 	if err := server.Run(context.Background(), &mcp.StdioTransport{}); err != nil {
 		log.Fatal(err)
 	}