@vasperacapital/vaspera-mcp-server 0.1.0 → 0.2.0

package/dist/cli.js

@@ -0,0 +1,3102 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/middleware/auth.ts
+import { QUOTA_LIMITS } from "@vasperacapital/vaspera-shared";
+async function validateApiKey(apiKey) {
+  if (!apiKey) {
+    return {
+      valid: false,
+      error: {
+        code: "VPM-API-KEY-001",
+        message: "API key is required. Set VASPERA_API_KEY environment variable."
+      }
+    };
+  }
+  if (!apiKey.startsWith("vpm_live_") && !apiKey.startsWith("vpm_test_")) {
+    return {
+      valid: false,
+      error: {
+        code: "VPM-API-KEY-002",
+        message: "Invalid API key format. Keys must start with vpm_live_ or vpm_test_"
+      }
+    };
+  }
+  try {
+    const response = await fetch(`${VALIDATE_KEY_URL}/api/validate-key`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ apiKey })
+    });
+    const data = await response.json();
+    if (!response.ok || !data.valid) {
+      return {
+        valid: false,
+        error: data.error || {
+          code: "VPM-API-KEY-002",
+          message: "Invalid API key"
+        }
+      };
+    }
+    return {
+      valid: true,
+      userId: data.user?.id,
+      apiKeyId: data.key?.id,
+      tier: data.user?.subscriptionTier,
+      scopes: data.key?.scopes || [],
+      quota: data.quota
+    };
+  } catch (error2) {
+    console.error("API key validation error:", error2);
+    if (process.env.NODE_ENV === "development" && apiKey.startsWith("vpm_test_")) {
+      console.error("Using offline test mode");
+      return {
+        valid: true,
+        userId: "test-user",
+        apiKeyId: "test-key",
+        tier: "free",
+        scopes: ["*"],
+        quota: {
+          limit: QUOTA_LIMITS.free,
+          used: 0,
+          remaining: QUOTA_LIMITS.free
+        }
+      };
+    }
+    return {
+      valid: false,
+      error: {
+        code: "VPM-INTERNAL-001",
+        message: "Failed to validate API key. Please try again."
+      }
+    };
+  }
+}
+var VALIDATE_KEY_URL;
+var init_auth = __esm({
+  "src/middleware/auth.ts"() {
+    "use strict";
+    VALIDATE_KEY_URL = process.env.VASPERA_API_URL || "https://vaspera.dev";
+  }
+});
+
+// src/middleware/usage.ts
+async function trackUsage(event) {
+  if (!INTERNAL_SERVICE_KEY) {
+    console.error("INTERNAL_SERVICE_KEY not configured, skipping usage tracking");
+    return;
+  }
+  try {
+    const response = await fetch(`${USAGE_API_URL}/api/usage`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${INTERNAL_SERVICE_KEY}`
+      },
+      body: JSON.stringify({
+        userId: event.userId,
+        apiKeyId: event.apiKeyId,
+        toolName: event.toolName,
+        tokensUsed: event.tokensUsed,
+        latencyMs: event.latencyMs,
+        success: event.success,
+        errorCode: event.errorCode,
+        metadata: event.metadata,
+        requestId: generateRequestId()
+      })
+    });
+    if (!response.ok) {
+      const error2 = await response.json().catch(() => ({}));
+      console.error("Failed to track usage:", error2);
+    }
+  } catch (error2) {
+    console.error("Usage tracking error:", error2);
+  }
+}
+function generateRequestId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `req_${timestamp}_${random}`;
+}
+var USAGE_API_URL, INTERNAL_SERVICE_KEY;
+var init_usage = __esm({
+  "src/middleware/usage.ts"() {
+    "use strict";
+    USAGE_API_URL = process.env.VASPERA_API_URL || "https://vaspera.dev";
+    INTERNAL_SERVICE_KEY = process.env.INTERNAL_SERVICE_KEY;
+  }
+});
+
+// src/middleware/rate-limit.ts
+async function checkRateLimit(userId, tier) {
+  const limit = RATE_LIMITS[tier] || RATE_LIMITS.free;
+  const windowMs = 6e4;
+  const now = Date.now();
+  const key = `rate:${userId}`;
+  let entry = rateLimitStore.get(key);
+  if (!entry || entry.resetAt < now) {
+    entry = {
+      count: 0,
+      resetAt: now + windowMs
+    };
+    rateLimitStore.set(key, entry);
+  }
+  if (entry.count >= limit) {
+    return {
+      allowed: false,
+      remaining: 0,
+      limit,
+      resetsAt: new Date(entry.resetAt)
+    };
+  }
+  entry.count++;
+  rateLimitStore.set(key, entry);
+  return {
+    allowed: true,
+    remaining: limit - entry.count,
+    limit,
+    resetsAt: new Date(entry.resetAt)
+  };
+}
+var RATE_LIMITS, rateLimitStore;
+var init_rate_limit = __esm({
+  "src/middleware/rate-limit.ts"() {
+    "use strict";
+    RATE_LIMITS = {
+      free: 5,
+      // 5 requests per minute
+      starter: 20,
+      // 20 requests per minute
+      pro: 60,
+      // 60 requests per minute (1 per second)
+      enterprise: 300
+      // 300 requests per minute (5 per second)
+    };
+    rateLimitStore = /* @__PURE__ */ new Map();
+    setInterval(() => {
+      const now = Date.now();
+      for (const [key, value] of rateLimitStore.entries()) {
+        if (value.resetAt < now) {
+          rateLimitStore.delete(key);
+        }
+      }
+    }, 6e4);
+  }
+});
+
+// src/tools/types.ts
+function jsonResult(data, tokensUsed) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    tokensUsed
+  };
+}
+function errorResult(message) {
+  return {
+    content: [{ type: "text", text: `Error: ${message}` }]
+  };
+}
+function markdownResult(markdown, tokensUsed) {
+  return {
+    content: [{ type: "text", text: markdown }],
+    tokensUsed
+  };
+}
+var init_types = __esm({
+  "src/tools/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/ai/client.ts
+import Anthropic from "@anthropic-ai/sdk";
+function getAnthropicClient() {
+  if (!anthropicClient) {
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      throw new Error("ANTHROPIC_API_KEY environment variable is required");
+    }
+    anthropicClient = new Anthropic({ apiKey });
+  }
+  return anthropicClient;
+}
+async function createCompletion(options) {
+  const client = getAnthropicClient();
+  const model = MODELS[options.model || "balanced"];
+  const response = await client.messages.create({
+    model,
+    max_tokens: options.maxTokens || 4096,
+    temperature: options.temperature ?? 0.7,
+    system: options.systemPrompt,
+    messages: [
+      {
+        role: "user",
+        content: options.userMessage
+      }
+    ]
+  });
+  const textContent = response.content.find((c) => c.type === "text");
+  const text = textContent?.type === "text" ? textContent.text : "";
+  return {
+    text,
+    inputTokens: response.usage.input_tokens,
+    outputTokens: response.usage.output_tokens
+  };
+}
+async function createJsonCompletion(options) {
+  const result = await createCompletion({
+    ...options,
+    systemPrompt: `${options.systemPrompt}
+
+IMPORTANT: Respond ONLY with valid JSON. No markdown, no explanation, just the JSON object.`,
+    temperature: 0.3
+    // Lower temperature for structured output
+  });
+  let jsonText = result.text.trim();
+  if (jsonText.startsWith("```json")) {
+    jsonText = jsonText.slice(7);
+  } else if (jsonText.startsWith("```")) {
+    jsonText = jsonText.slice(3);
+  }
+  if (jsonText.endsWith("```")) {
+    jsonText = jsonText.slice(0, -3);
+  }
+  jsonText = jsonText.trim();
+  try {
+    const data = JSON.parse(jsonText);
+    return {
+      data,
+      inputTokens: result.inputTokens,
+      outputTokens: result.outputTokens
+    };
+  } catch (error2) {
+    throw new Error(`Failed to parse AI response as JSON: ${result.text.substring(0, 200)}`);
+  }
+}
+var anthropicClient, MODELS;
+var init_client = __esm({
+  "src/ai/client.ts"() {
+    "use strict";
+    anthropicClient = null;
+    MODELS = {
+      fast: "claude-3-5-haiku-20241022",
+      // Quick responses, lower cost
+      balanced: "claude-sonnet-4-20250514",
+      // Good balance of speed and quality
+      powerful: "claude-sonnet-4-20250514"
+      // Best quality for complex tasks
+    };
+  }
+});
+
+// src/tools/explode-backlog.ts
+var explodeBacklogTool;
+var init_explode_backlog = __esm({
+  "src/tools/explode-backlog.ts"() {
+    "use strict";
+    init_types();
+    init_client();
+    explodeBacklogTool = {
+      tool: {
+        name: "explode_backlog",
+        description: `Break down high-level features or epics into detailed, actionable user stories.
+
+Takes a feature description and generates:
+- User stories with acceptance criteria
+- Story point estimates
+- Priority recommendations
+- Dependencies between stories
+
+Best for: Converting feature ideas into sprint-ready backlog items.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            feature: {
+              type: "string",
+              description: "The feature or epic to break down into user stories"
+            },
+            context: {
+              type: "string",
+              description: "Optional context about the product, tech stack, or constraints"
+            },
+            format: {
+              type: "string",
+              enum: ["markdown", "json", "jira", "linear"],
+              default: "markdown",
+              description: "Output format for the stories"
+            },
+            maxStories: {
+              type: "number",
+              default: 10,
+              description: "Maximum number of stories to generate"
+            }
+          },
+          required: ["feature"]
+        }
+      },
+      handler: async (args, validation) => {
+        const feature = args.feature;
+        const context = args.context;
+        const format = args.format || "markdown";
+        const maxStories = args.maxStories || 10;
+        if (!feature || feature.trim().length === 0) {
+          return errorResult("Feature description is required");
+        }
+        const systemPrompt = `You are an expert product manager and agile coach. Your task is to break down features into well-structured user stories.
+
+For each user story, provide:
+1. A clear title following the format: "As a [user], I want [goal] so that [benefit]"
+2. Detailed acceptance criteria (at least 3 per story)
+3. Story point estimate (1, 2, 3, 5, 8, or 13)
+4. Priority (High, Medium, Low)
+5. Any dependencies on other stories
+
+Guidelines:
+- Stories should be independent when possible
+- Each story should be completable in a single sprint
+- Include edge cases and error handling in acceptance criteria
+- Consider both happy path and error scenarios
+- Stories should be testable
+
+${context ? `Product Context: ${context}` : ""}`;
+        const userMessage = `Break down the following feature into ${maxStories} or fewer detailed user stories:
+
+Feature: ${feature}
+
+${format === "json" ? "Output as a JSON array of story objects." : format === "jira" ? "Format for Jira import (CSV-compatible)." : format === "linear" ? "Format for Linear import." : "Output in clean markdown format."}`;
+        try {
+          const result = await createCompletion({
+            systemPrompt,
+            userMessage,
+            model: "balanced",
+            maxTokens: 4096
+          });
+          const totalTokens = result.inputTokens + result.outputTokens;
+          return markdownResult(result.text, totalTokens);
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : "Unknown error";
+          return errorResult(`Failed to generate user stories: ${message}`);
+        }
+      },
+      requiredScope: "tools:explode_backlog"
+    };
+  }
+});
+
+// src/tools/infer-prd.ts
+var inferPrdTool;
+var init_infer_prd = __esm({
+  "src/tools/infer-prd.ts"() {
+    "use strict";
+    init_types();
+    init_client();
+    inferPrdTool = {
+      tool: {
+        name: "infer_prd_from_code",
+        description: `Analyze code and generate a Product Requirements Document (PRD).
+
+Takes code snippets, file structures, or repository descriptions and infers:
+- Product overview and purpose
+- Feature list with descriptions
+- User personas and use cases
+- Technical requirements
+- Non-functional requirements
+
+Best for: Documenting existing products or understanding inherited codebases.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            code: {
+              type: "string",
+              description: "Code snippets, file structure, or repository content to analyze"
+            },
+            repoDescription: {
+              type: "string",
+              description: "Optional description of the repository or project"
+            },
+            techStack: {
+              type: "string",
+              description: 'Technology stack used (e.g., "Next.js, TypeScript, PostgreSQL")'
+            },
+            focusAreas: {
+              type: "array",
+              items: { type: "string" },
+              description: 'Specific areas to focus on (e.g., ["authentication", "payments"])'
+            }
+          },
+          required: ["code"]
+        }
+      },
+      handler: async (args, validation) => {
+        const code = args.code;
+        const repoDescription = args.repoDescription;
+        const techStack = args.techStack;
+        const focusAreas = args.focusAreas;
+        if (!code || code.trim().length === 0) {
+          return errorResult("Code content is required");
+        }
+        const systemPrompt = `You are an expert product manager who specializes in reverse-engineering products from code. Your task is to analyze code and generate a comprehensive PRD.
+
+The PRD should include:
+1. **Product Overview** - What the product does and its purpose
+2. **Target Users** - Who uses this product and why
+3. **Core Features** - List of main features with descriptions
+4. **User Stories** - Key user journeys
+5. **Technical Requirements** - Architecture and technical constraints
+6. **Non-Functional Requirements** - Performance, security, scalability
+7. **Future Considerations** - Potential improvements or extensions
+
+Guidelines:
+- Infer purpose from code patterns and naming conventions
+- Identify API endpoints and their purposes
+- Note database schema and data models
+- Consider error handling and edge cases
+- Look for authentication/authorization patterns
+
+${techStack ? `Tech Stack: ${techStack}` : ""}
+${repoDescription ? `Repository Description: ${repoDescription}` : ""}
+${focusAreas?.length ? `Focus Areas: ${focusAreas.join(", ")}` : ""}`;
+        const userMessage = `Analyze the following code and generate a comprehensive PRD:
+
+\`\`\`
+${code.length > 15e3 ? code.substring(0, 15e3) + "\n... [truncated]" : code}
+\`\`\`
+
+Generate a detailed PRD in markdown format.`;
+        try {
+          const result = await createCompletion({
+            systemPrompt,
+            userMessage,
+            model: "balanced",
+            maxTokens: 4096
+          });
+          const totalTokens = result.inputTokens + result.outputTokens;
+          return markdownResult(result.text, totalTokens);
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : "Unknown error";
+          return errorResult(`Failed to generate PRD: ${message}`);
+        }
+      },
+      requiredScope: "tools:infer_prd"
+    };
+  }
+});
+
+// src/tools/synthesize-prd.ts
+var synthesizePrdTool;
+var init_synthesize_prd = __esm({
+  "src/tools/synthesize-prd.ts"() {
+    "use strict";
+    init_types();
+    init_client();
+    synthesizePrdTool = {
+      tool: {
+        name: "synthesize_master_prd",
+        description: `Synthesize multiple input documents into a unified Master PRD.
+
+Takes multiple sources (meeting notes, emails, specs, designs) and creates:
+- Unified product vision
+- Consolidated requirements
+- Prioritized feature list
+- Clear success metrics
+- Risk assessment
+
+Best for: Creating a single source of truth from scattered documentation.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            documents: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  title: { type: "string" },
+                  content: { type: "string" },
+                  type: {
+                    type: "string",
+                    enum: ["meeting_notes", "email", "spec", "design", "feedback", "other"]
+                  }
+                },
+                required: ["content"]
+              },
+              description: "Array of documents to synthesize"
+            },
+            productName: {
+              type: "string",
+              description: "Name of the product"
+            },
+            targetAudience: {
+              type: "string",
+              description: "Description of the target users"
+            },
+            constraints: {
+              type: "string",
+              description: "Any constraints (timeline, budget, tech limitations)"
+            }
+          },
+          required: ["documents"]
+        }
+      },
+      handler: async (args, validation) => {
+        const documents = args.documents;
+        const productName = args.productName;
+        const targetAudience = args.targetAudience;
+        const constraints = args.constraints;
+        if (!documents || documents.length === 0) {
+          return errorResult("At least one document is required");
+        }
+        const systemPrompt = `You are an expert product manager who excels at synthesizing scattered information into clear, actionable PRDs.
+
+Create a Master PRD with the following sections:
+1. **Executive Summary** - High-level overview
+2. **Product Vision** - What we're building and why
+3. **Target Users** - Who benefits and their needs
+4. **Goals & Success Metrics** - How we measure success
+5. **Features & Requirements** - Detailed feature list with priorities
+6. **User Journeys** - Key workflows
+7. **Technical Considerations** - Architecture implications
+8. **Risks & Mitigations** - What could go wrong
+9. **Timeline & Milestones** - High-level roadmap
+10. **Open Questions** - Items needing clarification
+
+Guidelines:
+- Resolve contradictions between documents by noting them
+- Extract implicit requirements from feedback and discussions
+- Identify gaps that need stakeholder input
+- Prioritize based on user impact and business value
+
+${productName ? `Product Name: ${productName}` : ""}
+${targetAudience ? `Target Audience: ${targetAudience}` : ""}
+${constraints ? `Constraints: ${constraints}` : ""}`;
+        const formattedDocs = documents.map((doc, i) => {
+          const title = doc.title || `Document ${i + 1}`;
+          const type = doc.type || "other";
+          return `### ${title} (${type})
+${doc.content}`;
+        }).join("\n\n---\n\n");
+        const userMessage = `Synthesize the following documents into a comprehensive Master PRD:
+
+${formattedDocs.length > 2e4 ? formattedDocs.substring(0, 2e4) + "\n... [truncated]" : formattedDocs}
+
+Create a unified PRD that captures all requirements and resolves any conflicts.`;
+        try {
+          const result = await createCompletion({
+            systemPrompt,
+            userMessage,
+            model: "balanced",
+            maxTokens: 6e3
+          });
+          const totalTokens = result.inputTokens + result.outputTokens;
+          return markdownResult(result.text, totalTokens);
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : "Unknown error";
+          return errorResult(`Failed to synthesize PRD: ${message}`);
+        }
+      },
+      requiredScope: "tools:synthesize_prd"
+    };
+  }
+});
+
+// src/tools/generate-architecture.ts
+var generateArchitectureTool;
+var init_generate_architecture = __esm({
+  "src/tools/generate-architecture.ts"() {
+    "use strict";
+    init_types();
+    init_client();
+    generateArchitectureTool = {
+      tool: {
+        name: "generate_architecture",
+        description: `Generate a technical architecture document from product requirements.
+
+Takes a PRD or feature description and creates:
+- System architecture diagram (in Mermaid)
+- Component breakdown
+- Data models and schemas
+- API design recommendations
+- Technology stack suggestions
+- Scalability considerations
+
+Best for: Translating product requirements into technical specifications.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            requirements: {
+              type: "string",
+              description: "Product requirements or PRD content"
+            },
+            existingStack: {
+              type: "string",
+              description: "Existing technology stack to build upon"
+            },
+            constraints: {
+              type: "object",
+              properties: {
+                budget: { type: "string" },
+                timeline: { type: "string" },
+                team: { type: "string" },
+                compliance: { type: "array", items: { type: "string" } }
+              },
+              description: "Technical and business constraints"
+            },
+            focus: {
+              type: "string",
+              enum: ["backend", "frontend", "fullstack", "infrastructure", "data"],
+              default: "fullstack",
+              description: "Architecture focus area"
+            }
+          },
+          required: ["requirements"]
+        }
+      },
+      handler: async (args, validation) => {
+        const requirements = args.requirements;
+        const existingStack = args.existingStack;
+        const constraints = args.constraints;
+        const focus = args.focus || "fullstack";
+        if (!requirements || requirements.trim().length === 0) {
+          return errorResult("Requirements are required");
+        }
+        const systemPrompt = `You are a senior solutions architect specializing in modern software systems. Your task is to create a comprehensive technical architecture document.
+
+Include the following sections:
+1. **Architecture Overview** - High-level system design
+2. **System Diagram** - Mermaid diagram showing components
+3. **Components** - Detailed breakdown of each component
+4. **Data Models** - Entity relationships and schemas
+5. **API Design** - Endpoint structure and contracts
+6. **Technology Recommendations** - Stack choices with rationale
+7. **Security Architecture** - Auth, encryption, access control
+8. **Scalability Plan** - How the system grows
+9. **Infrastructure** - Deployment and hosting
+10. **Risks & Trade-offs** - Technical debt and decisions
+
+Guidelines:
+- Use Mermaid syntax for diagrams
+- Consider SOLID principles and clean architecture
+- Recommend proven, maintainable technologies
+- Include performance considerations
+- Address data integrity and consistency
+
+Focus Area: ${focus}
+${existingStack ? `Existing Stack: ${existingStack}` : ""}
+${constraints ? `Constraints: ${JSON.stringify(constraints)}` : ""}`;
+        const userMessage = `Create a technical architecture for the following requirements:
+
+${requirements.length > 12e3 ? requirements.substring(0, 12e3) + "\n... [truncated]" : requirements}
+
+Generate a comprehensive architecture document with Mermaid diagrams.`;
+        try {
+          const result = await createCompletion({
+            systemPrompt,
+            userMessage,
+            model: "balanced",
+            maxTokens: 6e3
+          });
+          const totalTokens = result.inputTokens + result.outputTokens;
+          return markdownResult(result.text, totalTokens);
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : "Unknown error";
+          return errorResult(`Failed to generate architecture: ${message}`);
+        }
+      },
+      requiredScope: "tools:generate_architecture"
+    };
+  }
+});
+
+// src/tools/handoff-package.ts
+var handoffPackageTool;
+var init_handoff_package = __esm({
+  "src/tools/handoff-package.ts"() {
+    "use strict";
+    init_types();
+    init_client();
+    handoffPackageTool = {
+      tool: {
+        name: "handoff_package",
+        description: `Create a complete developer handoff package from PM artifacts.
+
+Takes PRD, designs, and specs to generate:
+- Implementation guide
+- Acceptance criteria checklist
+- Edge cases and error handling
+- Testing requirements
+- Definition of Done
+
+Best for: Preparing work for engineering sprint planning.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            prd: {
+              type: "string",
+              description: "Product Requirements Document content"
+            },
+            designs: {
+              type: "string",
+              description: "Design descriptions or Figma links"
+            },
+            techSpecs: {
+              type: "string",
+              description: "Technical specifications or architecture docs"
+            },
+            targetTeam: {
+              type: "string",
+              enum: ["frontend", "backend", "fullstack", "mobile", "devops"],
+              default: "fullstack",
+              description: "Target development team"
+            },
+            sprintDuration: {
+              type: "number",
+              default: 2,
+              description: "Sprint duration in weeks"
+            }
+          },
+          required: ["prd"]
+        }
+      },
+      handler: async (args, validation) => {
+        const prd = args.prd;
+        const designs = args.designs;
+        const techSpecs = args.techSpecs;
+        const targetTeam = args.targetTeam || "fullstack";
+        const sprintDuration = args.sprintDuration || 2;
+        if (!prd || prd.trim().length === 0) {
+          return errorResult("PRD content is required");
+        }
+        const systemPrompt = `You are an expert technical program manager who creates flawless developer handoff packages.
+
+Create a handoff package with:
+1. **Summary** - What we're building and why
+2. **Implementation Guide**
+   - Step-by-step implementation order
+   - Dependencies between components
+   - Critical path items
+3. **Acceptance Criteria** - Testable requirements for each feature
+4. **Edge Cases** - All the "what if" scenarios
+5. **Error Handling** - How errors should be handled
+6. **Testing Requirements**
+   - Unit test requirements
+   - Integration test scenarios
+   - E2E test flows
+7. **Definition of Done** - Checklist for completion
+8. **Questions for PM** - Clarifications needed
+9. **Risks** - Implementation risks to discuss
+
+Guidelines:
+- Be extremely specific - no ambiguity
+- Include code examples where helpful
+- Consider accessibility requirements
+- Note performance expectations
+- List any feature flags needed
+
+Target Team: ${targetTeam}
+Sprint Duration: ${sprintDuration} weeks`;
+        let userMessage = `Create a developer handoff package from:
+
+## PRD
+${prd.length > 1e4 ? prd.substring(0, 1e4) + "\n... [truncated]" : prd}`;
+        if (designs) {
+          userMessage += `
+
+## Design Specs
+${designs}`;
+        }
+        if (techSpecs) {
+          userMessage += `
+
+## Technical Specs
+${techSpecs}`;
+        }
+        userMessage += "\n\nCreate a comprehensive handoff package.";
+        try {
+          const result = await createCompletion({
+            systemPrompt,
+            userMessage,
+            model: "balanced",
+            maxTokens: 6e3
+          });
+          const totalTokens = result.inputTokens + result.outputTokens;
+          return markdownResult(result.text, totalTokens);
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : "Unknown error";
+          return errorResult(`Failed to create handoff package: ${message}`);
+        }
+      },
+      requiredScope: "tools:handoff_package"
+    };
+  }
+});
+
+// src/tools/synthesize-requirements.ts
+var synthesizeRequirementsTool;
+var init_synthesize_requirements = __esm({
+  "src/tools/synthesize-requirements.ts"() {
+    "use strict";
+    init_types();
+    init_client();
+    synthesizeRequirementsTool = {
+      tool: {
+        name: "synthesize_requirements",
+        description: `Extract and synthesize requirements from various input sources.
+
+Takes meeting notes, emails, slack threads, user feedback, or any unstructured input and produces:
+- Functional requirements (what the system must do)
+- Non-functional requirements (performance, security, scalability)
+- User stories in standard format
+- Acceptance criteria for each requirement
+- Requirement dependencies and priorities
+
+Best for: Converting messy stakeholder input into structured requirements.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            sources: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  content: { type: "string" },
+                  type: {
+                    type: "string",
+                    enum: ["meeting_notes", "email", "slack", "feedback", "interview", "survey", "other"]
+                  },
+                  stakeholder: { type: "string" },
+                  date: { type: "string" }
+                },
+                required: ["content"]
+              },
+              description: "Array of source documents to analyze"
+            },
+            context: {
+              type: "string",
+              description: "Product or feature context to help interpretation"
+            },
+            outputFormat: {
+              type: "string",
+              enum: ["user_stories", "requirements_doc", "both"],
+              default: "both",
+              description: "Output format preference"
+            },
+            priorityFramework: {
+              type: "string",
+              enum: ["moscow", "rice", "kano", "value_effort"],
+              default: "moscow",
+              description: "Prioritization framework to use"
+            }
+          },
+          required: ["sources"]
+        }
+      },
+      handler: async (args, validation) => {
+        const sources = args.sources;
+        const context = args.context;
+        const outputFormat = args.outputFormat || "both";
+        const priorityFramework = args.priorityFramework || "moscow";
+        if (!sources || sources.length === 0) {
+          return errorResult("At least one source document is required");
+        }
+        const priorityDescriptions = {
+          moscow: "MoSCoW (Must have, Should have, Could have, Won't have)",
+          rice: "RICE (Reach, Impact, Confidence, Effort)",
+          kano: "Kano Model (Basic, Performance, Excitement)",
+          value_effort: "Value/Effort Matrix (Quick wins, Big bets, Fill-ins, Time sinks)"
+        };
+        const systemPrompt = `You are a senior business analyst expert at extracting clear requirements from ambiguous stakeholder input.
+
+Your task is to analyze the provided sources and produce structured requirements.
+
+Output Sections:
+1. **Executive Summary** - Key themes and scope overview
+2. **Functional Requirements** - What the system must do
+   - ID, Description, Priority, Source reference
+3. **Non-Functional Requirements** - Quality attributes
+   - Performance, Security, Scalability, Accessibility, etc.
+4. **User Stories** - In "As a [role], I want [feature], so that [benefit]" format
+   - Include acceptance criteria for each
+5. **Requirement Dependencies** - Which requirements depend on others
+6. **Priority Matrix** - Using ${priorityDescriptions[priorityFramework]}
+7. **Gaps & Ambiguities** - What's unclear or missing
+8. **Recommended Clarifications** - Questions for stakeholders
+
+Guidelines:
+- Extract implicit requirements (things stakeholders assume but didn't state)
+- Note conflicting requirements and flag for resolution
+- Use unique IDs for traceability (REQ-001, US-001, etc.)
+- Map each requirement back to its source
+- Consider edge cases mentioned in discussions
+
+${context ? `Product Context: ${context}` : ""}`;
+        const formattedSources = sources.map((source, i) => {
+          const meta = [
+            source.type ? `Type: ${source.type}` : null,
+            source.stakeholder ? `Stakeholder: ${source.stakeholder}` : null,
+            source.date ? `Date: ${source.date}` : null
+          ].filter(Boolean).join(" | ");
+          return `### Source ${i + 1}${meta ? ` (${meta})` : ""}
+${source.content}`;
+        }).join("\n\n---\n\n");
+        const userMessage = `Analyze these sources and extract structured requirements:
+
+${formattedSources.length > 15e3 ? formattedSources.substring(0, 15e3) + "\n... [truncated]" : formattedSources}
+
+Output format preference: ${outputFormat}
+Prioritization framework: ${priorityFramework}
+
+Extract all requirements with proper structure and traceability.`;
+        try {
+          const result = await createCompletion({
+            systemPrompt,
+            userMessage,
+            model: "balanced",
+            maxTokens: 6e3
+          });
+          const totalTokens = result.inputTokens + result.outputTokens;
+          return markdownResult(result.text, totalTokens);
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : "Unknown error";
+          return errorResult(`Failed to synthesize requirements: ${message}`);
+        }
+      },
+      requiredScope: "tools:synthesize_requirements"
+    };
+  }
+});
+
+// src/tools/review-prd.ts
+var reviewPrdTool;
+var init_review_prd = __esm({
+  "src/tools/review-prd.ts"() {
+    "use strict";
+    init_types();
+    init_client();
+    reviewPrdTool = {
+      tool: {
+        name: "review_prd",
+        description: `Review and critique a Product Requirements Document.
+
+Analyzes a PRD against best practices and provides:
+- Completeness assessment
+- Clarity and ambiguity analysis
+- Gap identification
+- Risk assessment
+- Improvement suggestions
+- Readiness score
+
+Best for: Quality assurance before engineering handoff.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            prd: {
+              type: "string",
+              description: "The PRD content to review"
+            },
+            reviewFocus: {
+              type: "array",
+              items: {
+                type: "string",
+                enum: [
+                  "completeness",
+                  "clarity",
+                  "technical_feasibility",
+                  "user_value",
+                  "metrics",
+                  "edge_cases",
+                  "security",
+                  "accessibility"
+                ]
+              },
+              default: ["completeness", "clarity", "technical_feasibility"],
+              description: "Areas to focus the review on"
+            },
+            targetAudience: {
+              type: "string",
+              enum: ["engineering", "stakeholders", "both"],
+              default: "engineering",
+              description: "Primary audience for the PRD"
+            },
+            strictness: {
+              type: "string",
+              enum: ["lenient", "standard", "strict"],
+              default: "standard",
+              description: "How strict the review should be"
+            }
+          },
+          required: ["prd"]
+        }
+      },
+      handler: async (args, validation) => {
+        const prd = args.prd;
+        const reviewFocus = args.reviewFocus || [
+          "completeness",
+          "clarity",
+          "technical_feasibility"
+        ];
+        const targetAudience = args.targetAudience || "engineering";
+        const strictness = args.strictness || "standard";
+        if (!prd || prd.trim().length === 0) {
+          return errorResult("PRD content is required for review");
+        }
+        const strictnessGuide = {
+          lenient: "Be constructive and focus on major issues only. Assume good intent and fill in reasonable gaps.",
+          standard: "Balance thoroughness with practicality. Flag important issues but don't nitpick.",
+          strict: "Apply rigorous standards. Flag all issues, ambiguities, and potential problems. This PRD should be bulletproof."
+        };
+        const systemPrompt = `You are a senior product management coach who has reviewed thousands of PRDs. Your job is to provide actionable, constructive feedback.
+
+Review the PRD with these priorities:
+${reviewFocus.map((f) => `- ${f}`).join("\n")}
+
+Provide a structured review with:
+
+1. **Overall Assessment**
+   - Readiness Score (1-10)
+   - Summary judgment (Ready / Needs Work / Major Revision Needed)
+
+2. **Strengths**
+   - What's done well
+
+3. **Completeness Analysis**
+   - Required sections present/missing
+   - Depth of coverage
+
+4. **Clarity Issues**
+   - Ambiguous requirements (quote specific text)
+   - Missing definitions
+   - Unclear scope boundaries
+
+5. **Technical Feasibility Concerns**
+   - Potentially challenging requirements
+   - Missing technical considerations
+   - Architecture implications not addressed
+
+6. **Gap Analysis**
+   - Missing use cases
+   - Unaddressed edge cases
+   - Missing acceptance criteria
+
+7. **Risk Assessment**
+   - Implementation risks
+   - Timeline risks
+   - Dependency risks
+
+8. **Specific Recommendations**
+   - Prioritized list of improvements
+   - Suggested rewrites for unclear sections
+
+9. **Questions for PM**
+   - Clarifications needed before engineering can start
+
+Review Strictness: ${strictnessGuide[strictness]}
+Target Audience: ${targetAudience}`;
+        const userMessage = `Review this PRD and provide comprehensive feedback:
+
+${prd.length > 15e3 ? prd.substring(0, 15e3) + "\n... [truncated]" : prd}
+
+Provide a thorough review with actionable feedback.`;
+        try {
+          const result = await createCompletion({
+            systemPrompt,
+            userMessage,
+            model: "balanced",
+            maxTokens: 5e3
+          });
+          const totalTokens = result.inputTokens + result.outputTokens;
+          return markdownResult(result.text, totalTokens);
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : "Unknown error";
+          return errorResult(`Failed to review PRD: ${message}`);
+        }
+      },
+      requiredScope: "tools:review_prd"
+    };
+  }
+});
+
+// src/tools/sync-to-tracker.ts
+var syncToTrackerTool;
+var init_sync_to_tracker = __esm({
+  "src/tools/sync-to-tracker.ts"() {
+    "use strict";
+    init_types();
+    init_client();
+    syncToTrackerTool = {
+      tool: {
+        name: "sync_to_tracker",
+        description: `Format requirements and user stories for import into project management tools.
+
+Takes requirements or a PRD and generates properly formatted items for:
+- Jira (Epics, Stories, Tasks, Subtasks)
+- Linear (Projects, Issues, Sub-issues)
+- GitHub Issues (Issues with labels and milestones)
+- Asana (Projects, Tasks, Subtasks)
+- Notion (Database entries)
+
+Output includes import instructions and properly structured data.
+
+Best for: Automated backlog population from requirements documents.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            requirements: {
+              type: "string",
+              description: "Requirements document, PRD, or user stories to convert"
+            },
+            platform: {
+              type: "string",
+              enum: ["jira", "linear", "github", "asana", "notion"],
+              default: "jira",
+              description: "Target project management platform"
+            },
+            projectKey: {
+              type: "string",
+              description: "Project key/identifier (e.g., PROJ for Jira)"
+            },
+            epicName: {
+              type: "string",
+              description: "Parent epic name for all generated items"
+            },
+            defaultLabels: {
+              type: "array",
+              items: { type: "string" },
+              description: "Default labels to apply to all items"
+            },
+            includeEstimates: {
+              type: "boolean",
+              default: true,
+              description: "Whether to include effort estimates"
+            },
+            estimateUnit: {
+              type: "string",
+              enum: ["story_points", "hours", "t_shirt"],
+              default: "story_points",
+              description: "Estimation unit to use"
+            }
+          },
+          required: ["requirements"]
+        }
+      },
+      handler: async (args, validation) => {
+        const requirements = args.requirements;
+        const platform = args.platform || "jira";
+        const projectKey = args.projectKey;
+        const epicName = args.epicName;
+        const defaultLabels = args.defaultLabels || [];
+        const includeEstimates = args.includeEstimates !== false;
+        const estimateUnit = args.estimateUnit || "story_points";
+        if (!requirements || requirements.trim().length === 0) {
+          return errorResult("Requirements content is required");
+        }
+        const platformConfig = {
+          jira: {
+            hierarchy: "Epic > Story > Task > Subtask",
+            estimateFormat: "Story points (fibonacci: 1, 2, 3, 5, 8, 13) or time (1h, 2h, 4h, 1d, 2d)"
+          },
+          linear: {
+            hierarchy: "Project > Issue > Sub-issue",
+            estimateFormat: "Linear points (0, 1, 2, 3, 5, 8)"
+          },
+          github: {
+            hierarchy: "Milestone > Issue",
+            estimateFormat: "T-shirt sizes in labels (size:S, size:M, size:L, size:XL)"
+          },
+          asana: {
+            hierarchy: "Project > Section > Task > Subtask",
+            estimateFormat: "Hours or days"
+          },
+          notion: {
+            hierarchy: "Database > Entry (with relations)",
+            estimateFormat: "Number property or select (S/M/L/XL)"
+          }
+        };
+        const config = platformConfig[platform];
+        if (!config) {
+          return errorResult(`Unsupported platform: ${platform}`);
+        }
+        const systemPrompt = `You are an expert at structuring work items for project management tools.
+
+Convert the requirements into structured items for ${platform.toUpperCase()}.
+
+Platform hierarchy: ${config.hierarchy}
+Estimate format: ${config.estimateFormat}
+${epicName ? `Parent Epic: ${epicName}` : ""}
+${defaultLabels.length > 0 ? `Default Labels: ${defaultLabels.join(", ")}` : ""}
+
+Output a JSON object with this structure:
+{
+  "platform": "${platform}",
+  "projectKey": "${projectKey || "PROJECT"}",
+  "items": [
+    {
+      "type": "epic|story|task|bug|subtask",
+      "title": "Clear, actionable title",
+      "description": "Detailed description with context",
+      "acceptanceCriteria": ["Criterion 1", "Criterion 2"],
+      "priority": "highest|high|medium|low|lowest",
+      "labels": ["label1", "label2"],
+      "estimate": "${includeEstimates ? "Appropriate estimate" : "null"}",
+      "parentRef": "Reference to parent item if subtask/child",
+      "customFields": {}
+    }
+  ],
+  "importInstructions": "Step-by-step instructions for importing into ${platform}"
+}
+
+Guidelines:
+- Create a logical hierarchy (epics contain stories, stories contain tasks)
+- Write clear, actionable titles (start with verb)
+- Include enough context in descriptions for developers
+- Add acceptance criteria for stories
+- Use appropriate priority based on business value and dependencies
+- Keep items appropriately sized (stories should be completable in 1 sprint)
+- Reference parent items for hierarchy
+${includeEstimates ? `- Include ${estimateUnit} estimates based on complexity` : "- Do not include estimates"}`;
+        const userMessage = `Convert these requirements into ${platform} items:
+
+${requirements.length > 12e3 ? requirements.substring(0, 12e3) + "\n... [truncated]" : requirements}
+
+Generate structured items ready for import.`;
+        try {
+          const result = await createJsonCompletion({
+            systemPrompt,
+            userMessage,
+            model: "balanced",
+            maxTokens: 6e3
+          });
+          const totalTokens = result.inputTokens + result.outputTokens;
+          const output = result.data;
+          output.platform = platform;
+          if (projectKey) output.projectKey = projectKey;
+          if (defaultLabels.length > 0 && output.items) {
+            output.items = output.items.map((item) => ({
+              ...item,
+              labels: [.../* @__PURE__ */ new Set([...item.labels || [], ...defaultLabels])]
+            }));
+          }
+          return jsonResult(output, totalTokens);
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : "Unknown error";
+          return errorResult(`Failed to format for tracker: ${message}`);
+        }
+      },
+      requiredScope: "tools:sync_to_tracker"
+    };
+  }
+});
+
+// src/tools/reverse-engineer-flows.ts
+var reverseEngineerFlowsTool;
+var init_reverse_engineer_flows = __esm({
+  "src/tools/reverse-engineer-flows.ts"() {
+    "use strict";
+    init_types();
+    init_client();
+    reverseEngineerFlowsTool = {
+      tool: {
+        name: "reverse_engineer_user_flows",
+        description: `Analyze code to extract and document user flows and journeys.
+
+Takes source code (routes, components, handlers) and produces:
+- User journey maps
+- Flow diagrams (Mermaid)
+- Screen/state transitions
+- API call sequences
+- Error handling paths
+- Edge case flows
+
+Best for: Documenting existing features or understanding inherited codebases.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            code: {
+              type: "string",
+              description: "Source code to analyze (routes, components, controllers)"
+            },
+            codeType: {
+              type: "string",
+              enum: ["frontend", "backend", "fullstack", "api"],
+              default: "fullstack",
+              description: "Type of code being analyzed"
+            },
+            featureName: {
+              type: "string",
+              description: "Name of the feature being analyzed"
+            },
+            outputFormat: {
+              type: "string",
+              enum: ["flows", "diagrams", "documentation", "all"],
+              default: "all",
+              description: "What to include in output"
+            },
+            includeErrorFlows: {
+              type: "boolean",
+              default: true,
+              description: "Whether to document error handling flows"
+            }
+          },
+          required: ["code"]
+        }
+      },
+      handler: async (args, validation) => {
+        const code = args.code;
+        const codeType = args.codeType || "fullstack";
+        const featureName = args.featureName;
+        const outputFormat = args.outputFormat || "all";
+        const includeErrorFlows = args.includeErrorFlows !== false;
+        if (!code || code.trim().length === 0) {
+          return errorResult("Source code is required for analysis");
+        }
+        const systemPrompt = `You are a senior engineer expert at reverse engineering user flows from code.
+
+Analyze the provided code and extract user flows.
+
+Output Sections:
+1. **Overview**
+   - Feature summary
+   - Entry points identified
+   - Key actors/roles
+
+2. **User Flows**
+   - Primary happy path
+   - Alternative paths
+   ${includeErrorFlows ? "- Error flows and recovery paths" : ""}
+   - Edge cases
+
+3. **Flow Diagram** (Mermaid)
+   \`\`\`mermaid
+   flowchart TD
+       Start --> Action --> Decision{Condition}
+       Decision -->|Yes| Success
+       Decision -->|No| Error
+   \`\`\`
+
+4. **State Transitions**
+   - UI states (loading, error, success, empty)
+   - Data states
+   - User state changes
+
+5. **API Sequence** (if applicable)
+   \`\`\`mermaid
+   sequenceDiagram
+       participant User
+       participant Frontend
+       participant API
+       participant Database
+   \`\`\`
+
+6. **Components/Screens**
+   - List of screens/components involved
+   - Their responsibilities
+   - Data dependencies
+
+7. **User Stories Derived**
+   - Inferred user stories from the code
+
+8. **Gaps & Recommendations**
+   - Missing error handling
+   - Undocumented edge cases
+   - Suggested improvements
+
+Code Type: ${codeType}
+${featureName ? `Feature: ${featureName}` : ""}`;
+        const userMessage = `Analyze this code and extract user flows:
+
+\`\`\`
+${code.length > 15e3 ? code.substring(0, 15e3) + "\n// ... [truncated]" : code}
+\`\`\`
+
+Document all user flows with diagrams.`;
+        try {
+          const result = await createCompletion({
+            systemPrompt,
+            userMessage,
+            model: "balanced",
+            maxTokens: 5e3
+          });
+          const totalTokens = result.inputTokens + result.outputTokens;
+          return markdownResult(result.text, totalTokens);
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : "Unknown error";
+          return errorResult(`Failed to reverse engineer flows: ${message}`);
+        }
+      },
+      requiredScope: "tools:reverse_engineer_flows"
+    };
+  }
+});
+
+// src/tools/generate-test-specs.ts
+var generateTestSpecsTool;
+var init_generate_test_specs = __esm({
+  "src/tools/generate-test-specs.ts"() {
+    "use strict";
+    init_types();
+    init_client();
+    generateTestSpecsTool = {
+      tool: {
+        name: "generate_test_specs",
+        description: `Generate comprehensive test specifications from requirements or code.
+
+Takes PRD, user stories, or source code and produces:
+- Test plan overview
+- Unit test specifications
+- Integration test scenarios
+- E2E test cases
+- Edge case coverage
+- Test data requirements
+- Accessibility testing checklist
+
+Best for: Ensuring comprehensive test coverage before or during development.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            input: {
+              type: "string",
+              description: "PRD, user stories, or source code to generate tests from"
+            },
+            inputType: {
+              type: "string",
+              enum: ["prd", "user_stories", "code", "api_spec"],
+              default: "prd",
+              description: "Type of input provided"
+            },
+            testTypes: {
+              type: "array",
+              items: {
+                type: "string",
+                enum: ["unit", "integration", "e2e", "api", "performance", "security", "accessibility"]
+              },
+              default: ["unit", "integration", "e2e"],
+              description: "Types of tests to generate"
+            },
+            framework: {
+              type: "string",
+              enum: ["jest", "vitest", "pytest", "playwright", "cypress", "generic"],
+              default: "generic",
+              description: "Testing framework for syntax hints"
+            },
+            coverage: {
+              type: "string",
+              enum: ["minimal", "standard", "comprehensive"],
+              default: "standard",
+              description: "How thorough the test coverage should be"
+            }
+          },
+          required: ["input"]
+        }
+      },
+      handler: async (args, validation) => {
+        const input = args.input;
+        const inputType = args.inputType || "prd";
+        const testTypes = args.testTypes || ["unit", "integration", "e2e"];
+        const framework = args.framework || "generic";
+        const coverage = args.coverage || "standard";
+        if (!input || input.trim().length === 0) {
+          return errorResult("Input (PRD, user stories, or code) is required");
+        }
+        const coverageGuide = {
+          minimal: "Focus on happy paths and critical functionality only",
+          standard: "Cover happy paths, common edge cases, and error scenarios",
+          comprehensive: "Cover all paths, edge cases, error scenarios, boundary conditions, and negative testing"
+        };
+        const systemPrompt = `You are a QA architect expert at creating comprehensive test specifications.
+
+Generate test specs from the provided ${inputType}.
+
+Test Types to Include: ${testTypes.join(", ")}
+Framework: ${framework}
+Coverage Level: ${coverageGuide[coverage]}
+
+Output Sections:
+
+1. **Test Plan Overview**
+   - Scope and objectives
+   - Test strategy
+   - Risk-based prioritization
+
+2. **Unit Tests** (if requested)
+   - Function/method level tests
+   - Mock requirements
+   - Edge cases per function
+   ${framework !== "generic" ? `- ${framework} code snippets` : ""}
+
+3. **Integration Tests** (if requested)
+   - Component interaction tests
+   - API contract tests
+   - Database integration tests
+
+4. **E2E Tests** (if requested)
+   - User journey scenarios
+   - Critical path coverage
+   - Cross-browser/device requirements
+
+5. **API Tests** (if requested)
+   - Endpoint coverage
+   - Request/response validation
+   - Error response testing
+
+6. **Performance Tests** (if requested)
+   - Load testing scenarios
+   - Response time expectations
+   - Concurrent user tests
+
+7. **Security Tests** (if requested)
+   - Authentication/authorization tests
+   - Input validation tests
+   - OWASP considerations
+
+8. **Accessibility Tests** (if requested)
+   - WCAG compliance checks
+   - Screen reader compatibility
+   - Keyboard navigation
+
+9. **Test Data Requirements**
+   - Fixtures needed
+   - Test user personas
+   - Mock data specifications
+
+10. **Acceptance Criteria Traceability**
+    - Map each test to a requirement
+    - Coverage matrix
+
+Format each test case as:
+\`\`\`
+Test ID: TC-XXX
+Title: [Descriptive title]
+Preconditions: [Setup required]
+Steps:
+1. [Action]
+2. [Action]
+Expected Result: [What should happen]
+Priority: High/Medium/Low
+\`\`\``;
+        const userMessage = `Generate test specifications from this ${inputType}:
+
+${input.length > 12e3 ? input.substring(0, 12e3) + "\n... [truncated]" : input}
+
+Create comprehensive test specs covering: ${testTypes.join(", ")}`;
+        try {
+          const result = await createCompletion({
+            systemPrompt,
+            userMessage,
+            model: "balanced",
+            maxTokens: 6e3
+          });
+          const totalTokens = result.inputTokens + result.outputTokens;
+          return markdownResult(result.text, totalTokens);
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : "Unknown error";
+          return errorResult(`Failed to generate test specs: ${message}`);
+        }
+      },
+      requiredScope: "tools:generate_test_specs"
+    };
+  }
+});
+
+// src/tools/explain-codebase.ts
+var explainCodebaseTool;
+var init_explain_codebase = __esm({
+  "src/tools/explain-codebase.ts"() {
+    "use strict";
+    init_types();
+    init_client();
+    explainCodebaseTool = {
+      tool: {
+        name: "explain_codebase",
+        description: `Analyze code and generate comprehensive documentation for product managers.
+
+Takes source code and produces PM-friendly documentation:
+- Architecture overview
+- Feature inventory
+- Data flow explanations
+- User-facing functionality mapping
+- Technical debt assessment
+- Business logic documentation
+
+Best for: Onboarding PMs to existing codebases or creating technical context.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            code: {
+              type: "string",
+              description: "Source code to analyze and explain"
+            },
+            projectName: {
+              type: "string",
+              description: "Name of the project"
+            },
+            codeContext: {
+              type: "string",
+              description: "Additional context about the codebase"
+            },
+            audience: {
+              type: "string",
+              enum: ["pm", "stakeholder", "new_engineer", "executive"],
+              default: "pm",
+              description: "Target audience for the documentation"
+            },
+            focus: {
+              type: "array",
+              items: {
+                type: "string",
+                enum: [
+                  "architecture",
+                  "features",
+                  "data_flow",
+                  "business_logic",
+                  "tech_debt",
+                  "dependencies",
+                  "security"
+                ]
+              },
+              default: ["architecture", "features", "business_logic"],
+              description: "Areas to focus documentation on"
+            },
+            detailLevel: {
+              type: "string",
+              enum: ["overview", "detailed", "deep_dive"],
+              default: "detailed",
+              description: "Level of detail in explanations"
+            }
+          },
+          required: ["code"]
+        }
+      },
+      handler: async (args, validation) => {
+        const code = args.code;
+        const projectName = args.projectName;
+        const codeContext = args.codeContext;
+        const audience = args.audience || "pm";
+        const focus = args.focus || ["architecture", "features", "business_logic"];
+        const detailLevel = args.detailLevel || "detailed";
+        if (!code || code.trim().length === 0) {
+          return errorResult("Source code is required for analysis");
+        }
+        const audienceGuide = {
+          pm: "Focus on product features, user value, and business logic. Avoid deep technical jargon.",
+          stakeholder: "High-level overview focusing on capabilities, risks, and business implications.",
+          new_engineer: "Technical detail with onboarding focus. Explain patterns, conventions, and gotchas.",
+          executive: "Strategic summary focusing on capabilities, technical health, and risks."
+        };
+        const systemPrompt = `You are a staff engineer who excels at explaining complex codebases to non-technical stakeholders.
+
+Analyze the code and create documentation for: ${audience}
+${audienceGuide[audience]}
+
+Documentation Focus: ${focus.join(", ")}
+Detail Level: ${detailLevel}
+${projectName ? `Project: ${projectName}` : ""}
+${codeContext ? `Context: ${codeContext}` : ""}
+
+Output Sections (include based on focus):
+
+1. **Executive Summary**
+   - What this code does in plain English
+   - Key capabilities
+   - Technology stack
+
+2. **Architecture Overview** (if in focus)
+   - System diagram (Mermaid)
+   - Key components and their roles
+   - How pieces fit together
+
+3. **Feature Inventory** (if in focus)
+   - List of user-facing features found
+   - Feature completeness assessment
+   - Hidden/admin features
+
+4. **Data Flow** (if in focus)
+   - How data moves through the system
+   - Key entities and relationships
+   - Data transformations
+
+5. **Business Logic Documentation** (if in focus)
+   - Core algorithms explained
+   - Business rules implemented
+   - Validation and constraints
+
+6. **Technical Debt Assessment** (if in focus)
+   - Code quality observations
+   - Maintenance concerns
+   - Refactoring opportunities
+
+7. **Dependencies** (if in focus)
+   - External services used
+   - Third-party libraries
+   - Integration points
+
+8. **Security Considerations** (if in focus)
+   - Authentication/authorization patterns
+   - Data protection measures
+   - Potential concerns
+
+9. **Glossary**
+   - Technical terms explained
+   - Domain-specific vocabulary
+
+Guidelines:
+- Use analogies for complex concepts
+- Include "What this means for product" sections
+- Highlight risks and opportunities
+- Be honest about limitations and unknowns`;
+        const userMessage = `Analyze and document this codebase:
+
+\`\`\`
+${code.length > 15e3 ? code.substring(0, 15e3) + "\n// ... [truncated]" : code}
+\`\`\`
+
+Create comprehensive documentation for a ${audience}.`;
+        try {
+          const result = await createCompletion({
+            systemPrompt,
+            userMessage,
+            model: "balanced",
+            maxTokens: 5e3
+          });
+          const totalTokens = result.inputTokens + result.outputTokens;
+          return markdownResult(result.text, totalTokens);
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : "Unknown error";
+          return errorResult(`Failed to explain codebase: ${message}`);
+        }
+      },
+      requiredScope: "tools:explain_codebase"
+    };
+  }
+});
+
+// src/tools/validate-implementation.ts
+var validateImplementationTool;
+var init_validate_implementation = __esm({
+  "src/tools/validate-implementation.ts"() {
+    "use strict";
+    init_types();
+    init_client();
+    validateImplementationTool = {
+      tool: {
+        name: "validate_implementation",
+        description: `Validate that code implementation matches requirements.
+
+Compares source code against PRD/requirements and produces:
+- Requirements coverage report
+- Gap analysis
+- Deviation documentation
+- Compliance checklist
+- Acceptance criteria verification
+
+Best for: Pre-release validation and QA support.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            requirements: {
+              type: "string",
+              description: "PRD, user stories, or requirements to validate against"
+            },
+            code: {
+              type: "string",
+              description: "Implementation code to validate"
+            },
+            strictness: {
+              type: "string",
+              enum: ["lenient", "standard", "strict"],
+              default: "standard",
+              description: "How strictly to validate"
+            },
+            checkTypes: {
+              type: "array",
+              items: {
+                type: "string",
+                enum: [
+                  "functional",
+                  "edge_cases",
+                  "error_handling",
+                  "performance",
+                  "security",
+                  "accessibility",
+                  "ux"
+                ]
+              },
+              default: ["functional", "edge_cases", "error_handling"],
+              description: "Types of validation to perform"
+            }
+          },
+          required: ["requirements", "code"]
+        }
+      },
+      handler: async (args, validation) => {
+        const requirements = args.requirements;
+        const code = args.code;
+        const strictness = args.strictness || "standard";
+        const checkTypes = args.checkTypes || [
+          "functional",
+          "edge_cases",
+          "error_handling"
+        ];
+        if (!requirements || requirements.trim().length === 0) {
+          return errorResult("Requirements are required for validation");
+        }
+        if (!code || code.trim().length === 0) {
+          return errorResult("Code is required for validation");
+        }
+        const strictnessGuide = {
+          lenient: "Accept reasonable interpretations. Flag only clear deviations from requirements.",
+          standard: "Check for requirement coverage and reasonable edge case handling. Flag gaps and concerns.",
+          strict: "Exact requirement matching. Every stated requirement must be verifiably implemented. Flag any ambiguity."
+        };
+        const systemPrompt = `You are a QA lead expert at validating implementations against requirements.
+
+Compare the code against the requirements and produce a validation report.
+
+Strictness: ${strictnessGuide[strictness]}
+Validation Types: ${checkTypes.join(", ")}
+
+Output Sections:
+
+1. **Validation Summary**
+   - Overall Score (0-100%)
+   - Verdict: Pass / Pass with Concerns / Fail
+   - Critical issues count
+
+2. **Requirements Coverage Matrix**
+   | Requirement | Status | Evidence | Notes |
+   |-------------|--------|----------|-------|
+   | REQ-1       | \u2705 Met  | Line 42  | -     |
+   | REQ-2       | \u26A0\uFE0F Partial | - | Missing edge case |
+   | REQ-3       | \u274C Not Met | - | Not implemented |
+
+3. **Functional Validation** (if checked)
+   - Each requirement with implementation evidence
+   - Quote code that implements each requirement
+
+4. **Edge Case Coverage** (if checked)
+   - Expected edge cases from requirements
+   - Which are handled in code
+   - Which are missing
+
+5. **Error Handling Review** (if checked)
+   - Error scenarios from requirements
+   - Implementation of each
+   - Missing error handling
+
+6. **Performance Validation** (if checked)
+   - Performance requirements stated
+   - Code patterns that address them
+   - Potential performance issues
+
+7. **Security Validation** (if checked)
+   - Security requirements stated
+   - Implementation verification
+   - Security concerns found
+
+8. **Accessibility Validation** (if checked)
+   - A11y requirements stated
+   - Implementation verification
+   - Missing accessibility features
+
+9. **UX Validation** (if checked)
+   - UX requirements stated
+   - Implementation verification
+   - UX concerns
+
+10. **Gaps & Deviations**
+    - Requirements not implemented
+    - Implementations that deviate from requirements
+    - Over-engineering concerns
+
+11. **Recommendations**
+    - Prioritized list of issues to fix
+    - Suggestions for improvement
+
+12. **Acceptance Criteria Checklist**
+    - [ ] Criterion 1: Status
+    - [ ] Criterion 2: Status`;
+        const reqTrunc = requirements.length > 8e3 ? requirements.substring(0, 8e3) + "\n... [truncated]" : requirements;
+        const codeTrunc = code.length > 1e4 ? code.substring(0, 1e4) + "\n// ... [truncated]" : code;
+        const userMessage = `Validate this implementation against the requirements:
+
+## Requirements
+${reqTrunc}
+
+## Implementation Code
+\`\`\`
+${codeTrunc}
+\`\`\`
+
+Produce a comprehensive validation report.`;
+        try {
+          const result = await createCompletion({
+            systemPrompt,
+            userMessage,
+            model: "balanced",
+            maxTokens: 5e3
+          });
+          const totalTokens = result.inputTokens + result.outputTokens;
+          return markdownResult(result.text, totalTokens);
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : "Unknown error";
+          return errorResult(`Failed to validate implementation: ${message}`);
+        }
+      },
+      requiredScope: "tools:validate_implementation"
+    };
+  }
+});
+
+// src/tools/suggest-refactors.ts
+var suggestRefactorsTool;
+var init_suggest_refactors = __esm({
+  "src/tools/suggest-refactors.ts"() {
+    "use strict";
+    init_types();
+    init_client();
+    suggestRefactorsTool = {
+      tool: {
+        name: "suggest_refactors",
+        description: `Analyze code and suggest refactoring opportunities for product planning.
+
+Takes source code and identifies:
+- Technical debt items
+- Refactoring opportunities
+- Architecture improvements
+- Performance optimizations
+- Maintainability issues
+
+Produces PM-friendly documentation for sprint planning.
+
+Best for: Technical debt prioritization and architecture evolution planning.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            code: {
+              type: "string",
+              description: "Source code to analyze for refactoring opportunities"
+            },
+            codeContext: {
+              type: "string",
+              description: "Context about the codebase or feature"
+            },
+            priorities: {
+              type: "array",
+              items: {
+                type: "string",
+                enum: [
+                  "performance",
+                  "maintainability",
+                  "scalability",
+                  "security",
+                  "testing",
+                  "readability"
+                ]
+              },
+              default: ["maintainability", "performance"],
+              description: "What to prioritize in suggestions"
+            },
+            riskTolerance: {
+              type: "string",
+              enum: ["low", "medium", "high"],
+              default: "medium",
+              description: "Risk tolerance for suggested changes"
+            },
+            teamSize: {
+              type: "string",
+              enum: ["small", "medium", "large"],
+              default: "medium",
+              description: "Team size context for effort estimates"
+            }
+          },
+          required: ["code"]
+        }
+      },
+      handler: async (args, validation) => {
+        const code = args.code;
+        const codeContext = args.codeContext;
+        const priorities = args.priorities || ["maintainability", "performance"];
+        const riskTolerance = args.riskTolerance || "medium";
+        const teamSize = args.teamSize || "medium";
+        if (!code || code.trim().length === 0) {
+          return errorResult("Source code is required for analysis");
+        }
+        const riskGuide = {
+          low: "Only suggest low-risk, incremental improvements. No major restructuring.",
+          medium: "Balance impact with risk. Include moderate restructuring where beneficial.",
+          high: "Include high-impact architectural changes. Transformative improvements acceptable."
+        };
+        const systemPrompt = `You are a staff engineer specializing in code quality and technical debt management.
+
+Analyze the code and suggest refactoring opportunities.
+
+Priorities: ${priorities.join(", ")}
+Risk Tolerance: ${riskGuide[riskTolerance]}
+Team Context: ${teamSize} team
+${codeContext ? `Context: ${codeContext}` : ""}
+
+Output Sections:
+
+1. **Executive Summary**
+   - Overall code health score (1-10)
+   - Top 3 priorities
+   - Estimated total refactoring effort
+
+2. **Quick Wins** (Low effort, immediate impact)
+   For each:
+   - Issue description
+   - Impact: [Performance/Maintainability/etc.]
+   - Effort: Small
+   - Risk: Low
+   - Code location hint
+   - Suggested approach
+
+3. **Medium-Term Improvements** (Moderate effort)
+   For each:
+   - Issue description
+   - Business impact (why PM should care)
+   - Effort: Medium (sprint-sized)
+   - Risk assessment
+   - Dependencies
+   - Suggested approach
+
+4. **Strategic Refactors** (Significant effort)
+   For each:
+   - Current state and problem
+   - Target state and benefits
+   - Business justification
+   - Effort: Large (multi-sprint)
+   - Risk and mitigation
+   - Incremental approach
+
+5. **Technical Debt Inventory**
+   | Item | Type | Severity | Effort | Risk | Priority |
+   |------|------|----------|--------|------|----------|
+
+6. **Anti-Patterns Identified**
+   - Pattern name
+   - Where found
+   - Why it's problematic
+   - Recommended pattern
+
+7. **Testing Debt**
+   - Missing test coverage areas
+   - Suggested testing improvements
+
+8. **Dependency Concerns**
+   - Outdated dependencies
+   - Security vulnerabilities risk
+   - Upgrade recommendations
+
+9. **Sprint Planning Recommendations**
+   - Suggested sprint allocation for tech debt
+   - Recommended sequence of refactors
+   - What to pair with feature work
+
+10. **Business Case Summary**
+    - PM-friendly explanation of why these matter
+    - Risk of not addressing
+    - Velocity impact
+
+Guidelines:
+- Frame everything in terms of business impact
+- Provide concrete before/after examples where helpful
+- Consider incremental approaches
+- Note any blockers or dependencies`;
+        const userMessage = `Analyze this code and suggest refactoring opportunities:
+
+\`\`\`
+${code.length > 15e3 ? code.substring(0, 15e3) + "\n// ... [truncated]" : code}
+\`\`\`
+
+Provide comprehensive refactoring suggestions for sprint planning.`;
+        try {
+          const result = await createCompletion({
+            systemPrompt,
+            userMessage,
+            model: "balanced",
+            maxTokens: 5e3
+          });
+          const totalTokens = result.inputTokens + result.outputTokens;
+          return markdownResult(result.text, totalTokens);
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : "Unknown error";
+          return errorResult(`Failed to suggest refactors: ${message}`);
+        }
+      },
+      requiredScope: "tools:suggest_refactors"
+    };
+  }
+});
+
+// src/tools/generate-api-docs.ts
+var generateApiDocsTool;
+var init_generate_api_docs = __esm({
+  "src/tools/generate-api-docs.ts"() {
+    "use strict";
+    init_types();
+    init_client();
+    generateApiDocsTool = {
+      tool: {
+        name: "generate_api_docs",
+        description: `Generate API documentation from source code.
+
+Analyzes API routes and generates:
+- OpenAPI 3.1 specification
+- Endpoint summaries
+- Request/response schemas
+- Authentication requirements
+- Example payloads
+
+Supports REST APIs in TypeScript/JavaScript, Python, Go, and more.
+
+Best for: Creating or updating API documentation from code.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            code: {
+              type: "string",
+              description: "API route code to analyze (routes, controllers, handlers)"
+            },
+            framework: {
+              type: "string",
+              enum: ["nextjs", "express", "fastify", "hono", "flask", "fastapi", "gin", "generic"],
+              default: "generic",
+              description: "API framework being used"
+            },
+            format: {
+              type: "string",
+              enum: ["openapi", "markdown", "both"],
+              default: "openapi",
+              description: "Output documentation format"
+            },
+            baseUrl: {
+              type: "string",
+              description: "Base URL for the API"
+            },
+            title: {
+              type: "string",
+              description: "API title for documentation"
+            },
+            version: {
+              type: "string",
+              default: "1.0.0",
+              description: "API version"
+            },
+            includeExamples: {
+              type: "boolean",
+              default: true,
+              description: "Whether to generate example payloads"
+            }
+          },
+          required: ["code"]
+        }
+      },
+      handler: async (args, validation) => {
+        const code = args.code;
+        const framework = args.framework || "generic";
+        const format = args.format || "openapi";
+        const baseUrl = args.baseUrl || "https://api.example.com";
+        const title = args.title || "API Documentation";
+        const version = args.version || "1.0.0";
+        const includeExamples = args.includeExamples !== false;
+        if (!code || code.trim().length === 0) {
+          return errorResult("API code is required for documentation generation");
+        }
+        const frameworkHints = {
+          nextjs: "Next.js App Router with route.ts files. Look for GET, POST, PUT, DELETE, PATCH exports.",
+          express: "Express.js with app.get(), app.post(), router patterns.",
+          fastify: "Fastify with fastify.get(), schema definitions.",
+          hono: "Hono framework with app.get(), c.json() patterns.",
+          flask: "Flask with @app.route decorators.",
+          fastapi: "FastAPI with @app.get() decorators and Pydantic models.",
+          gin: "Gin framework with r.GET(), r.POST() patterns.",
+          generic: "Generic API code - infer patterns from the code."
+        };
+        const systemPrompt = `You are an API documentation expert who generates OpenAPI 3.1 specifications from code.
+
+Framework: ${framework}
+${frameworkHints[framework]}
+
+Generate a complete OpenAPI 3.1 specification with:
+1. All endpoints with methods (GET, POST, PUT, DELETE, PATCH)
+2. Path parameters extracted from route patterns
+3. Query parameters from code analysis
+4. Request body schemas from TypeScript types or validation
+5. Response schemas for success and error cases
+6. Authentication requirements if detected
+7. Logical grouping with tags
+${includeExamples ? "8. Realistic example values for all schemas" : ""}
+
+Output a JSON object with:
+{
+  "openapi": "3.1.0",
+  "info": { "title": "${title}", "version": "${version}", "description": "..." },
+  "servers": [{ "url": "${baseUrl}", "description": "..." }],
+  "paths": { "/path": { "get": {...}, "post": {...} } },
+  "components": { "schemas": {...}, "securitySchemes": {...} },
+  "tags": [{ "name": "...", "description": "..." }]
+}
+
+Be thorough - extract every endpoint, parameter, and type from the code.`;
+        const userMessage = `Generate OpenAPI documentation from this ${framework} API code:
+
+\`\`\`
+${code.length > 15e3 ? code.substring(0, 15e3) + "\n// ... [truncated]" : code}
+\`\`\`
+
+Generate complete OpenAPI 3.1 specification.`;
+        try {
+          if (format === "markdown") {
+            const mdPrompt = `You are an API documentation expert. Generate clear, comprehensive markdown API documentation.
+
+Include:
+1. Overview and authentication
+2. Each endpoint with method, path, description
+3. Parameters table (name, type, required, description)
+4. Request body examples
+5. Response examples
+6. Error codes
+
+Framework: ${framework}`;
+            const result2 = await createCompletion({
+              systemPrompt: mdPrompt,
+              userMessage: `Document this API:
+
+\`\`\`
+${code.length > 12e3 ? code.substring(0, 12e3) + "\n// ..." : code}
+\`\`\``,
+              model: "balanced",
+              maxTokens: 5e3
+            });
+            return markdownResult(result2.text, result2.inputTokens + result2.outputTokens);
+          }
+          const result = await createJsonCompletion({
+            systemPrompt,
+            userMessage,
+            model: "balanced",
+            maxTokens: 6e3
+          });
+          const totalTokens = result.inputTokens + result.outputTokens;
+          if (format === "both") {
+            const mdResult = await createCompletion({
+              systemPrompt: "Summarize this OpenAPI spec as readable markdown documentation.",
+              userMessage: JSON.stringify(result.data, null, 2),
+              model: "fast",
+              maxTokens: 2e3
+            });
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `# ${title}
+
+${mdResult.text}
+
+---
+
+## OpenAPI Specification
+
+\`\`\`json
+${JSON.stringify(result.data, null, 2)}
+\`\`\``
+                }
+              ],
+              tokensUsed: totalTokens + mdResult.inputTokens + mdResult.outputTokens
+            };
+          }
+          return jsonResult(result.data, totalTokens);
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : "Unknown error";
+          return errorResult(`Failed to generate API docs: ${message}`);
+        }
+      },
+      requiredScope: "tools:generate_api_docs"
+    };
+  }
+});
+
+// src/tools/dependency-audit.ts
+var dependencyAuditTool;
+var init_dependency_audit = __esm({
+  "src/tools/dependency-audit.ts"() {
+    "use strict";
+    init_types();
+    init_client();
+    dependencyAuditTool = {
+      tool: {
+        name: "dependency_audit",
+        description: `Audit project dependencies for security, updates, and health.
+
+Analyzes package.json, requirements.txt, go.mod, or similar and provides:
+- Security vulnerability assessment
+- Outdated package identification
+- License compliance check
+- Bundle size impact analysis
+- Maintenance health scores
+- Upgrade recommendations with breaking change warnings
+
+Best for: Pre-release dependency review and security audits.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            manifest: {
+              type: "string",
+              description: "Dependency manifest content (package.json, requirements.txt, etc.)"
+            },
+            lockfile: {
+              type: "string",
+              description: "Optional lockfile content for version pinning analysis"
+            },
+            manifestType: {
+              type: "string",
+              enum: ["npm", "yarn", "pnpm", "pip", "poetry", "go", "cargo", "maven", "gradle"],
+              default: "npm",
+              description: "Package manager type"
+            },
+            checkTypes: {
+              type: "array",
+              items: {
+                type: "string",
+                enum: ["security", "updates", "licenses", "maintenance", "size", "duplicates"]
+              },
+              default: ["security", "updates", "maintenance"],
+              description: "Types of checks to perform"
+            },
+            severity: {
+              type: "string",
+              enum: ["all", "moderate", "high", "critical"],
+              default: "moderate",
+              description: "Minimum severity level to report"
+            }
+          },
+          required: ["manifest"]
+        }
+      },
+      handler: async (args, validation) => {
+        const manifest = args.manifest;
+        const lockfile = args.lockfile;
+        const manifestType = args.manifestType || "npm";
+        const checkTypes = args.checkTypes || ["security", "updates", "maintenance"];
+        const severity = args.severity || "moderate";
+        if (!manifest || manifest.trim().length === 0) {
+          return errorResult("Dependency manifest is required");
+        }
+        const severityLevels = {
+          all: "Report all issues including informational",
+          moderate: "Report moderate severity and above",
+          high: "Report only high and critical issues",
+          critical: "Report only critical issues"
+        };
+        const systemPrompt = `You are a security-focused DevOps engineer performing a comprehensive dependency audit.
+
+Package Manager: ${manifestType}
+Check Types: ${checkTypes.join(", ")}
+Severity Threshold: ${severityLevels[severity]}
+
+Provide a thorough audit report with:
+
+1. **Executive Summary**
+   - Overall health score (A-F)
+   - Critical issues count
+   - Recommended actions
+
+2. **Security Vulnerabilities** (if checked)
+   | Package | Version | Vulnerability | Severity | CVE | Fix Version |
+   |---------|---------|---------------|----------|-----|-------------|
+   - Include known CVEs where applicable
+   - Note if no known vulnerabilities
+
+3. **Outdated Packages** (if checked)
+   | Package | Current | Latest | Type | Breaking Changes |
+   |---------|---------|--------|------|------------------|
+   - Distinguish patch, minor, major updates
+   - Flag breaking changes in major updates
+
+4. **License Compliance** (if checked)
+   | Package | License | Risk Level | Notes |
+   |---------|---------|------------|-------|
+   - Flag copyleft licenses (GPL, AGPL)
+   - Note license compatibility issues
+
+5. **Maintenance Health** (if checked)
+   | Package | Last Update | Weekly Downloads | Issues | Health |
+   |---------|-------------|------------------|--------|--------|
+   - Flag abandoned packages (>2 years no update)
+   - Note packages with many open issues
+
+6. **Size Impact** (if checked)
+   | Package | Size | Gzipped | Alternatives |
+   |---------|------|---------|--------------|
+   - Identify heavy dependencies
+   - Suggest lighter alternatives
+
+7. **Duplicate Dependencies** (if checked)
+   - Identify packages included multiple times
+   - Note version conflicts
+
+8. **Recommendations**
+   - Prioritized list of actions
+   - Safe upgrade paths
+   - Packages to consider replacing
+
+Base your analysis on common knowledge about popular packages. Be conservative with security assessments - note when you're uncertain.`;
+        let userMessage = `Audit these dependencies:
+
+## Manifest (${manifestType})
+\`\`\`
+${manifest.length > 1e4 ? manifest.substring(0, 1e4) + "\n... [truncated]" : manifest}
+\`\`\``;
+        if (lockfile) {
+          userMessage += `
+
+## Lockfile
+\`\`\`
+${lockfile.length > 5e3 ? lockfile.substring(0, 5e3) + "\n... [truncated]" : lockfile}
+\`\`\``;
+        }
+        userMessage += "\n\nProvide a comprehensive dependency audit.";
+        try {
+          const result = await createCompletion({
+            systemPrompt,
+            userMessage,
+            model: "balanced",
+            maxTokens: 5e3
+          });
+          const totalTokens = result.inputTokens + result.outputTokens;
+          return markdownResult(result.text, totalTokens);
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : "Unknown error";
+          return errorResult(`Failed to audit dependencies: ${message}`);
+        }
+      },
+      requiredScope: "tools:dependency_audit"
+    };
+  }
+});
+
+// src/tools/estimate-migration.ts
+var estimateMigrationTool;
+var init_estimate_migration = __esm({
+  "src/tools/estimate-migration.ts"() {
+    "use strict";
+    init_types();
+    init_client();
+    estimateMigrationTool = {
+      tool: {
+        name: "estimate_migration",
+        description: `Estimate the effort required for a code migration or major upgrade.
+
+Analyzes current code and target state to provide:
+- Effort estimation (story points, days)
+- Risk assessment
+- Breaking changes analysis
+- Migration path recommendations
+- Rollback strategy
+
+Supports: Framework upgrades, language migrations, architecture changes, dependency updates.
+
+Best for: Sprint planning for major technical initiatives.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            currentCode: {
+              type: "string",
+              description: "Current codebase sample to analyze"
+            },
+            migrationType: {
+              type: "string",
+              enum: [
+                "framework_upgrade",
+                "language_migration",
+                "architecture_change",
+                "dependency_upgrade",
+                "database_migration",
+                "cloud_migration",
+                "monolith_to_microservices",
+                "other"
+              ],
+              description: "Type of migration being planned"
+            },
+            from: {
+              type: "string",
+              description: 'Current technology/version (e.g., "React 17", "Python 2.7")'
+            },
+            to: {
+              type: "string",
+              description: 'Target technology/version (e.g., "React 18", "Python 3.11")'
+            },
+            codebaseSize: {
+              type: "string",
+              enum: ["small", "medium", "large", "enterprise"],
+              default: "medium",
+              description: "Approximate codebase size"
+            },
+            teamSize: {
+              type: "number",
+              default: 3,
+              description: "Number of developers available for migration"
+            },
+            constraints: {
+              type: "string",
+              description: "Any constraints (timeline, budget, parallel development)"
+            }
+          },
+          required: ["migrationType", "from", "to"]
+        }
+      },
+      handler: async (args, validation) => {
+        const currentCode = args.currentCode;
+        const migrationType = args.migrationType;
+        const from = args.from;
+        const to = args.to;
+        const codebaseSize = args.codebaseSize || "medium";
+        const teamSize = args.teamSize || 3;
+        const constraints = args.constraints;
+        if (!migrationType || !from || !to) {
+          return errorResult("Migration type, from, and to are required");
+        }
+        const sizeMultipliers = {
+          small: "<10k LOC, few dependencies",
+          medium: "10k-50k LOC, moderate complexity",
+          large: "50k-200k LOC, many integrations",
+          enterprise: ">200k LOC, complex architecture"
+        };
+        const systemPrompt = `You are a senior technical architect who specializes in migration planning.
+
+Estimate the effort for migrating from "${from}" to "${to}".
+
+Migration Type: ${migrationType}
+Codebase Size: ${codebaseSize} (${sizeMultipliers[codebaseSize]})
+Team Size: ${teamSize} developers
+${constraints ? `Constraints: ${constraints}` : ""}
+
+Provide a comprehensive migration estimate with:
+
+1. **Executive Summary**
+   - Total estimated effort (story points and calendar time)
+   - Risk level (Low/Medium/High/Critical)
+   - Recommended approach (Big bang / Incremental / Strangler fig)
+
+2. **Effort Breakdown**
+   | Phase | Tasks | Story Points | Calendar Days | Parallel? |
+   |-------|-------|--------------|---------------|-----------|
+   - Phase 1: Assessment & Planning
+   - Phase 2: Infrastructure Setup
+   - Phase 3: Code Migration
+   - Phase 4: Testing & Validation
+   - Phase 5: Deployment & Cutover
+
+3. **Breaking Changes Analysis**
+   | Area | Impact | Effort | Notes |
+   |------|--------|--------|-------|
+   - API changes
+   - Dependency updates
+   - Configuration changes
+   - Data format changes
+
+4. **Risk Assessment**
+   | Risk | Probability | Impact | Mitigation |
+   |------|-------------|--------|------------|
+
+5. **Migration Path**
+   - Step-by-step migration strategy
+   - Dependencies between steps
+   - Parallel work opportunities
+
+6. **Testing Strategy**
+   - Unit test updates needed
+   - Integration test requirements
+   - Performance benchmarking
+   - Regression testing approach
+
+7. **Rollback Strategy**
+   - Feature flags approach
+   - Database rollback plan
+   - Traffic shifting strategy
+
+8. **Resource Requirements**
+   - Skills needed
+   - Infrastructure for parallel environments
+   - Tools and automation
+
+9. **Assumptions & Caveats**
+   - What could change the estimate
+   - Unknown risks
+
+10. **Sprint Breakdown** (for ${teamSize} developers)
+    - Sprint 1: ...
+    - Sprint 2: ...
+    - etc.
+
+Be realistic and include buffer for unknowns. Better to overestimate than underestimate.`;
+        let userMessage = `Estimate migration effort for:
+
+**From:** ${from}
+**To:** ${to}
+**Type:** ${migrationType}`;
+        if (currentCode) {
+          userMessage += `
+
+**Sample of Current Code:**
+\`\`\`
+${currentCode.length > 8e3 ? currentCode.substring(0, 8e3) + "\n// ..." : currentCode}
+\`\`\``;
+        }
+        userMessage += "\n\nProvide a comprehensive migration estimate.";
+        try {
+          const result = await createCompletion({
+            systemPrompt,
+            userMessage,
+            model: "balanced",
+            maxTokens: 5e3
+          });
+          const totalTokens = result.inputTokens + result.outputTokens;
+          return markdownResult(result.text, totalTokens);
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : "Unknown error";
+          return errorResult(`Failed to estimate migration: ${message}`);
+        }
+      },
+      requiredScope: "tools:estimate_migration"
+    };
+  }
+});
+
+// src/tools/index.ts
+var toolDefinitions, tools, toolHandlers;
+var init_tools = __esm({
+  "src/tools/index.ts"() {
+    "use strict";
+    init_explode_backlog();
+    init_infer_prd();
+    init_synthesize_prd();
+    init_generate_architecture();
+    init_handoff_package();
+    init_synthesize_requirements();
+    init_review_prd();
+    init_sync_to_tracker();
+    init_reverse_engineer_flows();
+    init_generate_test_specs();
+    init_explain_codebase();
+    init_validate_implementation();
+    init_suggest_refactors();
+    init_generate_api_docs();
+    init_dependency_audit();
+    init_estimate_migration();
+    init_types();
+    toolDefinitions = [
+      // Phase 3: Initial tools
+      explodeBacklogTool,
+      inferPrdTool,
+      synthesizePrdTool,
+      generateArchitectureTool,
+      handoffPackageTool,
+      // Phase 4: Additional PM tools
+      synthesizeRequirementsTool,
+      reviewPrdTool,
+      syncToTrackerTool,
+      // Phase 5: Code-first tools
+      reverseEngineerFlowsTool,
+      generateTestSpecsTool,
+      explainCodebaseTool,
+      validateImplementationTool,
+      suggestRefactorsTool,
+      // Phase 6: Advanced tools
+      generateApiDocsTool,
+      dependencyAuditTool,
+      estimateMigrationTool
+    ];
+    tools = toolDefinitions.map((t) => t.tool);
+    toolHandlers = Object.fromEntries(
+      toolDefinitions.map((t) => [t.tool.name, t.handler])
+    );
+  }
+});
+
+// src/server.ts
+var server_exports = {};
+__export(server_exports, {
+  startServer: () => startServer
+});
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ErrorCode,
+  McpError
+} from "@modelcontextprotocol/sdk/types.js";
+function sanitizeArgs(args) {
+  if (!args) return {};
+  const sanitized = {};
+  for (const [key, value] of Object.entries(args)) {
+    if (key.toLowerCase().includes("key") || key.toLowerCase().includes("secret") || key.toLowerCase().includes("token")) {
+      sanitized[key] = "[REDACTED]";
+    } else if (typeof value === "string" && value.length > 500) {
+      sanitized[key] = value.substring(0, 500) + "...[truncated]";
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
+async function startServer() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(`VasperaPM MCP Server v${VERSION} running`);
+}
+var VERSION, server;
+var init_server = __esm({
+  "src/server.ts"() {
+    "use strict";
+    init_auth();
+    init_usage();
+    init_rate_limit();
+    init_tools();
+    VERSION = "0.1.1";
+    server = new Server(
+      {
+        name: "vaspera-pm",
+        version: VERSION
+      },
+      {
+        capabilities: {
+          tools: {}
+        }
+      }
+    );
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return { tools };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      const apiKey = process.env.VASPERA_API_KEY || args?._apiKey;
+      const validation = await validateApiKey(apiKey);
+      if (!validation.valid) {
+        return {
+          content: [{ type: "text", text: `Authentication failed: ${validation.error?.message || "Invalid API key"}` }],
+          isError: true
+        };
+      }
+      const rateCheck = await checkRateLimit(validation.userId, validation.tier);
+      if (!rateCheck.allowed) {
+        return {
+          content: [{ type: "text", text: `Rate limit exceeded. ${rateCheck.remaining} calls remaining. Resets at ${rateCheck.resetsAt?.toISOString()}` }],
+          isError: true
+        };
+      }
+      if (validation.quota && validation.quota.remaining <= 0) {
+        return {
+          content: [{ type: "text", text: `Monthly quota exceeded. Upgrade your plan for more API calls.` }],
+          isError: true
+        };
+      }
+      const startTime = Date.now();
+      let result;
+      let success2 = true;
+      let errorCode;
+      let tokensUsed = 0;
+      try {
+        const handler = toolHandlers[name];
+        if (!handler) {
+          throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+        }
+        const cleanArgs = { ...args };
+        delete cleanArgs._apiKey;
+        const toolResult = await handler(cleanArgs, validation);
+        result = toolResult.content;
+        tokensUsed = toolResult.tokensUsed || 0;
+      } catch (error2) {
+        success2 = false;
+        errorCode = error2 instanceof McpError ? error2.code.toString() : "TOOL_ERROR";
+        const errorMessage = error2 instanceof Error ? error2.message : "Unknown error";
+        result = [{ type: "text", text: `Error: ${errorMessage}` }];
+      }
+      const latencyMs = Date.now() - startTime;
+      trackUsage({
+        userId: validation.userId,
+        apiKeyId: validation.apiKeyId,
+        toolName: name,
+        tokensUsed,
+        latencyMs,
+        success: success2,
+        errorCode,
+        metadata: { args: sanitizeArgs(args) }
+      }).catch((err) => {
+        console.error("Failed to track usage:", err);
+      });
+      return {
+        content: result,
+        isError: !success2
+      };
+    });
+    if (import.meta.url === `file://${process.argv[1]}`) {
+      startServer().catch((error2) => {
+        console.error("Failed to start MCP server:", error2);
+        process.exit(1);
+      });
+    }
+  }
+});
+
+// src/cli.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { createInterface } from "readline";
+var BANNER = `
+\x1B[36m\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551                                                               \u2551
+\u2551   \u2588\u2588\u2557   \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2557    \u2551
+\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557   \u2551
+\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551   \u2551
+\u2551   \u255A\u2588\u2588\u2557 \u2588\u2588\u2554\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551   \u2551
+\u2551    \u255A\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551   \u2551
+\u2551     \u255A\u2550\u2550\u2550\u255D  \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D   \u2551
+\u2551                                                               \u2551
+\u2551              \x1B[33mAI-Powered Product Management\x1B[36m                    \u2551
+\u2551                                                               \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D\x1B[0m
+`;
+var VERSION2 = "0.1.1";
+var HELP = `
+\x1B[1mUsage:\x1B[0m vasperapm <command> [options]
+
+\x1B[1mCommands:\x1B[0m
+  \x1B[32minstall\x1B[0m     Configure VasperaPM with Claude Code
+  \x1B[32mconnect\x1B[0m     Set up your API key and integrations
+  \x1B[32mserve\x1B[0m       Start the MCP server (used by Claude Code)
+  \x1B[32mstatus\x1B[0m      Check your current configuration
+  \x1B[32mhelp\x1B[0m        Show this help message
+
+\x1B[1mExamples:\x1B[0m
+  $ vasperapm install     # Set up VasperaPM with Claude Code
+  $ vasperapm connect     # Configure API key interactively
+  $ vasperapm status      # Check configuration status
+
+\x1B[1mDocumentation:\x1B[0m
+  https://github.com/rcolkitt/VasperaPM
+
+\x1B[1mGet an API Key:\x1B[0m
+  https://vasperapm.com/dashboard
+`;
+function getClaudeConfigPath() {
+  return join(homedir(), ".claude", "claude_desktop_config.json");
+}
+function getVasperaConfigPath() {
+  return join(homedir(), ".vasperapm", "config.json");
+}
+function readJsonFile(path) {
+  try {
+    if (!existsSync(path)) return null;
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeJsonFile(path, data) {
+  const dir = path.substring(0, path.lastIndexOf("/"));
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(path, JSON.stringify(data, null, 2));
+}
+function prompt(question) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function success(message) {
+  console.log(`\x1B[32m\u2713\x1B[0m ${message}`);
+}
+function error(message) {
+  console.log(`\x1B[31m\u2717\x1B[0m ${message}`);
+}
+function info(message) {
+  console.log(`\x1B[36m\u2139\x1B[0m ${message}`);
+}
+function warn(message) {
+  console.log(`\x1B[33m\u26A0\x1B[0m ${message}`);
+}
+async function install() {
+  console.log(BANNER);
+  console.log("\x1B[1mInstalling VasperaPM for Claude Code...\x1B[0m\n");
+  const configPath = getClaudeConfigPath();
+  let config = readJsonFile(configPath);
+  if (!config) {
+    config = { mcpServers: {} };
+    info("Creating Claude Code configuration...");
+  }
+  if (!config.mcpServers) {
+    config.mcpServers = {};
+  }
+  if (config.mcpServers["vaspera-pm"]) {
+    warn("VasperaPM is already installed in Claude Code.");
+    const answer = await prompt("\nDo you want to reinstall? (y/N): ");
+    if (answer.toLowerCase() !== "y") {
+      info("Installation cancelled.");
+      return;
+    }
+  }
+  const vasperaConfig = readJsonFile(getVasperaConfigPath());
+  let apiKey = vasperaConfig?.apiKey || process.env.VASPERA_API_KEY || "";
+  if (!apiKey) {
+    console.log("\n\x1B[1mAPI Key Setup\x1B[0m");
+    console.log("Get your API key at: \x1B[36mhttps://vasperapm.com/dashboard\x1B[0m\n");
+    apiKey = await prompt("Enter your VasperaPM API key (or press Enter to use test mode): ");
+    if (!apiKey) {
+      apiKey = "vpm_test_local_development_key_for_testing";
+      info("Using test mode API key (limited features)");
+    }
+  }
+  config.mcpServers["vaspera-pm"] = {
+    command: "vasperapm",
+    args: ["serve"],
+    env: {
+      VASPERA_API_KEY: apiKey,
+      NODE_ENV: apiKey.includes("test") ? "development" : "production"
+    }
+  };
+  writeJsonFile(configPath, config);
+  const vasperaDir = join(homedir(), ".vasperapm");
+  if (!existsSync(vasperaDir)) {
+    mkdirSync(vasperaDir, { recursive: true });
+  }
+  writeJsonFile(getVasperaConfigPath(), { apiKey });
+  console.log("\n");
+  success("VasperaPM installed successfully!");
+  console.log("\n\x1B[1mNext steps:\x1B[0m");
+  console.log("  1. Restart Claude Code (or VSCode)");
+  console.log("  2. Look for VasperaPM tools in the MCP panel");
+  console.log('  3. Try: "Generate a PRD for a todo app"\n');
+  console.log("\x1B[1mAvailable Tools:\x1B[0m");
+  console.log("  \x1B[33m\u2022\x1B[0m generate_prd          - Create PRDs from context");
+  console.log("  \x1B[33m\u2022\x1B[0m infer_prd_from_code   - Analyze code to generate PRD");
+  console.log("  \x1B[33m\u2022\x1B[0m generate_code         - Generate code from PRD");
+  console.log("  \x1B[33m\u2022\x1B[0m sync_jira/linear/github - Sync with PM tools");
+  console.log("  \x1B[33m\u2022\x1B[0m generate_api_spec     - Create OpenAPI specs");
+  console.log("  \x1B[33m\u2022\x1B[0m generate_test_cases   - Create test plans\n");
+}
+async function connect() {
+  console.log(BANNER);
+  console.log("\x1B[1mConnect VasperaPM to your services...\x1B[0m\n");
+  console.log("\x1B[1m1. API Key\x1B[0m");
+  const vasperaConfig = readJsonFile(getVasperaConfigPath());
+  if (vasperaConfig?.apiKey) {
+    const masked = vasperaConfig.apiKey.substring(0, 12) + "..." + vasperaConfig.apiKey.substring(vasperaConfig.apiKey.length - 4);
+    info(`Current API key: ${masked}`);
+    const answer = await prompt("Update API key? (y/N): ");
+    if (answer.toLowerCase() !== "y") {
+      success("Keeping existing API key");
+    } else {
+      const newKey = await prompt("Enter new API key: ");
+      if (newKey) {
+        writeJsonFile(getVasperaConfigPath(), { ...vasperaConfig, apiKey: newKey });
+        success("API key updated");
+      }
+    }
+  } else {
+    console.log("Get your API key at: \x1B[36mhttps://vasperapm.com/dashboard\x1B[0m\n");
+    const apiKey = await prompt("Enter your VasperaPM API key: ");
+    if (apiKey) {
+      writeJsonFile(getVasperaConfigPath(), { apiKey });
+      success("API key saved");
+    } else {
+      warn("No API key provided. Some features will be limited.");
+    }
+  }
+  console.log("\n\x1B[1m2. Integrations\x1B[0m");
+  console.log("Configure integrations at: \x1B[36mhttps://vasperapm.com/dashboard/integrations\x1B[0m\n");
+  console.log("  \x1B[33m\u2022\x1B[0m Jira     - Sync PRDs to Jira epics/stories");
+  console.log("  \x1B[33m\u2022\x1B[0m Linear   - Export tasks to Linear projects");
+  console.log("  \x1B[33m\u2022\x1B[0m GitHub   - Create issues and track progress\n");
+  success("Connection setup complete!");
+  console.log("\nRun \x1B[36mvasperapm status\x1B[0m to check your configuration.\n");
+}
+async function status() {
+  console.log(BANNER);
+  console.log("\x1B[1mVasperaPM Status\x1B[0m\n");
+  const vasperaConfig = readJsonFile(getVasperaConfigPath());
+  if (vasperaConfig?.apiKey) {
+    const masked = vasperaConfig.apiKey.substring(0, 12) + "..." + vasperaConfig.apiKey.substring(vasperaConfig.apiKey.length - 4);
+    success(`API Key: ${masked}`);
+    if (vasperaConfig.apiKey.includes("_live_")) {
+      info("Mode: Production");
+    } else if (vasperaConfig.apiKey.includes("_test_")) {
+      info("Mode: Test/Development");
+    }
+  } else {
+    warn("API Key: Not configured");
+    console.log("  Run \x1B[36mvasperapm connect\x1B[0m to set up your API key\n");
+  }
+  const claudeConfig = readJsonFile(getClaudeConfigPath());
+  if (claudeConfig?.mcpServers?.["vaspera-pm"]) {
+    success("Claude Code: Installed");
+  } else {
+    warn("Claude Code: Not installed");
+    console.log("  Run \x1B[36mvasperapm install\x1B[0m to set up Claude Code integration\n");
+  }
+  console.log(`
+\x1B[1mVersion:\x1B[0m ${VERSION2}`);
+  console.log("\x1B[1mDocs:\x1B[0m https://github.com/rcolkitt/VasperaPM\n");
+}
+async function serve() {
+  const { startServer: startServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+  await startServer2();
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0]?.toLowerCase();
+  switch (command) {
+    case "install":
+      await install();
+      break;
+    case "connect":
+      await connect();
+      break;
+    case "serve":
+      await serve();
+      break;
+    case "status":
+      await status();
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+      console.log(BANNER);
+      console.log(HELP);
+      break;
+    case "--version":
+    case "-v":
+      console.log(`vasperapm v${VERSION2}`);
+      break;
+    case void 0:
+      console.log(BANNER);
+      console.log(HELP);
+      break;
+    default:
+      error(`Unknown command: ${command}`);
+      console.log(HELP);
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  error(err.message);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map