@schilling.mark.a/software-methodology 1.0.0 → 1.0.1

package/mcp-server/src/tools/next-step-suggester.ts

@@ -0,0 +1,243 @@
+import { MethodologyRepository } from "../repository.js";
+import { promises as fs } from "fs";
+import { join } from "path";
+
+export class NextStepSuggester {
+  constructor(private repository: MethodologyRepository) {}
+
+  async suggest(projectPath?: string) {
+    const context = await this.analyzeProjectContext(projectPath);
+    const suggestion = this.determineSuggestion(context);
+    
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: suggestion,
+        },
+      ],
+    };
+  }
+
+  private async analyzeProjectContext(projectPath?: string): Promise<{
+    hasVPC: boolean;
+    hasBMC: boolean;
+    hasStoryMap: boolean;
+    hasFeatureFiles: boolean;
+    hasTests: boolean;
+    testsPassing: boolean;
+    hasPipeline: boolean;
+  }> {
+    const docsPath = projectPath ? join(projectPath, "docs") : join(process.cwd(), "docs");
+    
+    try {
+      const vpcContent = await this.repository.readVPC();
+      const storyMapContent = await this.repository.readStoryMap();
+      const featureFiles = await this.repository.listFeatureFiles(projectPath);
+      
+      return {
+        hasVPC: !!vpcContent,
+        hasBMC: await this.fileExists(join(docsPath, "business-model-canvas.md")),
+        hasStoryMap: !!storyMapContent,
+        hasFeatureFiles: featureFiles.length > 0,
+        hasTests: await this.hasTestFiles(projectPath),
+        testsPassing: false, // TODO: Implement test execution check
+        hasPipeline: await this.hasPipelineConfig(projectPath),
+      };
+    } catch {
+      return {
+        hasVPC: false,
+        hasBMC: false,
+        hasStoryMap: false,
+        hasFeatureFiles: false,
+        hasTests: false,
+        testsPassing: false,
+        hasPipeline: false,
+      };
+    }
+  }
+
+  private determineSuggestion(context: {
+    hasVPC: boolean;
+    hasBMC: boolean;
+    hasStoryMap: boolean;
+    hasFeatureFiles: boolean;
+    hasTests: boolean;
+    testsPassing: boolean;
+    hasPipeline: boolean;
+  }): string {
+    if (!context.hasVPC) {
+      return `# Next Step: Create Value Proposition Canvas
+
+You should start by defining business value using the Value Proposition Canvas.
+
+**Why:** The VPC establishes the foundation for all downstream work. It defines customer segments, jobs, pains, and gains that inform every feature decision.
+
+**Reference:** product-strategy/SKILL.md
+
+**What to create:** /docs/value-proposition-canvas.md
+
+The VPC should include:
+- Customer segments (who are your users?)
+- Customer jobs (what are they trying to accomplish?)
+- Pains (what frustrates them?)
+- Gains (what success looks like)
+- Pain relievers (how your product helps)
+- Gain creators (how your product delivers value)`;
+    }
+
+    if (!context.hasStoryMap) {
+      return `# Next Step: Create Story Map Backbone
+
+You have a Value Proposition Canvas. Now organize user activities into a story map.
+
+**Why:** The story map backbone organizes work by user activities (derived from VPC customer jobs) rather than technical components.
+
+**Reference:** story-mapping/SKILL.md
+
+**What to create:** /docs/story-map/backbone.md
+
+Each customer job from the VPC becomes one user activity in the backbone.`;
+    }
+
+    if (!context.hasFeatureFiles) {
+      return `# Next Step: Write Gherkin Scenarios
+
+You have a story map. Now specify behavior using concrete examples.
+
+**Why:** Gherkin scenarios define "done" before implementation starts. They become executable acceptance tests.
+
+**Reference:** bdd-specification/SKILL.md
+
+**What to create:** /features/*.feature
+
+Each scenario should:
+- Use Given-When-Then format
+- Trace "So that" clause to a VPC gain
+- Specify observable user outcomes`;
+    }
+
+    if (!context.hasTests) {
+      return `# Next Step: Write Failing Acceptance Test (RED Phase)
+
+You have Gherkin scenarios. Now write automated tests that verify them.
+
+**Why:** Test-first development defines success criteria before implementation. Tests fail initially because the feature doesn't exist yet.
+
+**Reference:** atdd-workflow/red-phase.md
+
+**What to do:**
+1. Pick one Gherkin scenario
+2. Write automated test that verifies it
+3. Run test and confirm it fails with clear error message
+4. Proceed to GREEN phase once RED phase passes`;
+    }
+
+    if (context.hasTests && !context.testsPassing) {
+      return `# Next Step: Make Tests Pass (GREEN Phase)
+
+You have failing tests. Now implement minimum code to make them pass.
+
+**Why:** GREEN phase focuses on making it work, not making it perfect. Simplicity first, optimization later.
+
+**Reference:** atdd-workflow/green-phase.md
+
+**What to do:**
+1. Write simplest implementation that passes the test
+2. No premature optimization
+3. No "future-proofing"
+4. Run tests until they pass
+5. Proceed to REFACTOR phase once tests are green`;
+    }
+
+    if (context.testsPassing) {
+      return `# Next Step: Refactor for Maintainability
+
+You have passing tests. Now improve code structure.
+
+**Why:** REFACTOR phase is where clean code principles apply. With tests protecting you, safely improve structure.
+
+**References:**
+- atdd-workflow/refactor-phase.md
+- clean-code/solid.md
+
+**What to do:**
+1. Keep tests green throughout refactoring
+2. Apply SOLID principles
+3. Extract duplications
+4. Use ubiquitous language
+5. Reference clean-code patterns as needed`;
+    }
+
+    if (!context.hasPipeline) {
+      return `# Next Step: Set Up CI/CD Pipeline
+
+You have tested code. Now automate deployment.
+
+**Why:** Automated pipeline builds, tests, and deploys code without manual steps. Makes frequent delivery safe and easy.
+
+**Reference:** cicd-pipeline/SKILL.md
+
+**What to create:** Pipeline configuration (e.g., .github/workflows/ci.yml)
+
+Pipeline should include:
+- Build stage
+- Test stage (runs all tests)
+- Deploy stage (on successful tests)`;
+    }
+
+    return `# Next Step: Measure and Improve
+
+You have a complete delivery workflow. Now collect data and iterate.
+
+**Why:** Continuous improvement validates that delivered features create expected value and identifies process improvements.
+
+**Reference:** continuous-improvement/SKILL.md
+
+**What to do:**
+1. Define success metrics (connects to VPC gains)
+2. Collect measurement data
+3. Perform root cause analysis when issues arise
+4. Update upstream artifacts based on learnings`;
+  }
+
+  private async fileExists(path: string): Promise<boolean> {
+    try {
+      await fs.access(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  private async hasTestFiles(projectPath?: string): Promise<boolean> {
+    const testDirs = ["test", "tests", "spec", "__tests__"];
+    const basePath = projectPath || process.cwd();
+    
+    for (const dir of testDirs) {
+      if (await this.fileExists(join(basePath, dir))) {
+        return true;
+      }
+    }
+    
+    return false;
+  }
+
+  private async hasPipelineConfig(projectPath?: string): Promise<boolean> {
+    const pipelineFiles = [
+      ".github/workflows",
+      ".gitlab-ci.yml",
+      "Jenkinsfile",
+      ".circleci/config.yml",
+    ];
+    const basePath = projectPath || process.cwd();
+    
+    for (const file of pipelineFiles) {
+      if (await this.fileExists(join(basePath, file))) {
+        return true;
+      }
+    }
+    
+    return false;
+  }
+}

package/mcp-server/src/tools/reference-reader.ts

@@ -0,0 +1,71 @@
+import { MethodologyRepository } from "../repository.js";
+
+export class ReferenceReader {
+  constructor(private repository: MethodologyRepository) {}
+
+  async readReference(referencePath: string) {
+    // Parse path like "clean-code/solid.md"
+    const parts = referencePath.split("/");
+    if (parts.length !== 2) {
+      throw new Error(
+        "Reference path must be in format 'skill-name/reference-name.md'"
+      );
+    }
+
+    const [skillName, referenceName] = parts;
+
+    try {
+      const content = await this.repository.readReference(skillName, referenceName);
+      
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: content,
+          },
+        ],
+      };
+    } catch (error) {
+      const references = await this.repository.listReferences(skillName);
+      
+      if (references.length === 0) {
+        throw new Error(
+          `Skill '${skillName}' has no reference documents or doesn't exist`
+        );
+      }
+      
+      const availableRefs = references.map((r) => r.name).join(", ");
+      throw new Error(
+        `Reference '${referenceName}' not found in skill '${skillName}'. Available references: ${availableRefs}`
+      );
+    }
+  }
+
+  async listReferences(skillName: string) {
+    const references = await this.repository.listReferences(skillName);
+    
+    if (references.length === 0) {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Skill '${skillName}' has no reference documents.`,
+          },
+        ],
+      };
+    }
+
+    const text = references
+      .map((ref) => `- ${ref.name}`)
+      .join("\n");
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `# References for ${skillName} (${references.length})\n\n${text}`,
+        },
+      ],
+    };
+  }
+}

package/mcp-server/src/tools/skill-reader.ts

@@ -0,0 +1,47 @@
+import { MethodologyRepository } from "../repository.js";
+
+export class SkillReader {
+  constructor(private repository: MethodologyRepository) {}
+
+  async readSkill(skillName: string) {
+    try {
+      const content = await this.repository.readSkill(skillName);
+      
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: content,
+          },
+        ],
+      };
+    } catch (error) {
+      const skills = await this.repository.listSkills();
+      const availableSkills = skills.map((s) => s.name).join(", ");
+      
+      throw new Error(
+        `Skill '${skillName}' not found. Available skills: ${availableSkills}`
+      );
+    }
+  }
+
+  async listSkills() {
+    const skills = await this.repository.listSkills();
+    
+    const text = skills
+      .map(
+        (skill) =>
+          `**${skill.displayName}** (${skill.name}):\n  ${skill.description}`
+      )
+      .join("\n\n");
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `# Available Skills (${skills.length})\n\n${text}`,
+        },
+      ],
+    };
+  }
+}

package/mcp-server/src/tools/vpc-querier.ts

@@ -0,0 +1,201 @@
+import { MethodologyRepository } from "../repository.js";
+
+interface VPCSegment {
+  name: string;
+  customerJobs: string[];
+  pains: string[];
+  gains: string[];
+}
+
+export class VPCQuerier {
+  constructor(private repository: MethodologyRepository) {}
+
+  async getSegments() {
+    const vpc = await this.repository.readVPC();
+    const segments = this.parseSegments(vpc);
+    
+    const text = segments.map((s) => `- ${s.name}`).join("\n");
+    
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `# Customer Segments (${segments.length})\n\n${text}`,
+        },
+      ],
+    };
+  }
+
+  async getCustomerJobs(segmentName: string) {
+    const vpc = await this.repository.readVPC();
+    const segments = this.parseSegments(vpc);
+    const segment = segments.find((s) => s.name === segmentName);
+    
+    if (!segment) {
+      const available = segments.map((s) => s.name).join(", ");
+      throw new Error(
+        `Segment '${segmentName}' not found. Available segments: ${available}`
+      );
+    }
+
+    const text = segment.customerJobs
+      .map((job, i) => `${i + 1}. ${job}`)
+      .join("\n");
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `# Customer Jobs for ${segmentName}\n\n${text}`,
+        },
+      ],
+    };
+  }
+
+  async getPains(segmentName: string) {
+    const vpc = await this.repository.readVPC();
+    const segments = this.parseSegments(vpc);
+    const segment = segments.find((s) => s.name === segmentName);
+    
+    if (!segment) {
+      const available = segments.map((s) => s.name).join(", ");
+      throw new Error(
+        `Segment '${segmentName}' not found. Available segments: ${available}`
+      );
+    }
+
+    const text = segment.pains
+      .map((pain, i) => `${i + 1}. ${pain}`)
+      .join("\n");
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `# Pains for ${segmentName}\n\n${text}`,
+        },
+      ],
+    };
+  }
+
+  async getGains(segmentName: string) {
+    const vpc = await this.repository.readVPC();
+    const segments = this.parseSegments(vpc);
+    const segment = segments.find((s) => s.name === segmentName);
+    
+    if (!segment) {
+      const available = segments.map((s) => s.name).join(", ");
+      throw new Error(
+        `Segment '${segmentName}' not found. Available segments: ${available}`
+      );
+    }
+
+    const text = segment.gains
+      .map((gain, i) => `${i + 1}. ${gain}`)
+      .join("\n");
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `# Gains for ${segmentName}\n\n${text}`,
+        },
+      ],
+    };
+  }
+
+  async search(query: string) {
+    const vpc = await this.repository.readVPC();
+    const segments = this.parseSegments(vpc);
+    const results: Array<{ segment: string; type: "pain" | "gain"; text: string }> = [];
+
+    const queryLower = query.toLowerCase();
+
+    for (const segment of segments) {
+      for (const pain of segment.pains) {
+        if (pain.toLowerCase().includes(queryLower)) {
+          results.push({ segment: segment.name, type: "pain", text: pain });
+        }
+      }
+      for (const gain of segment.gains) {
+        if (gain.toLowerCase().includes(queryLower)) {
+          results.push({ segment: segment.name, type: "gain", text: gain });
+        }
+      }
+    }
+
+    if (results.length === 0) {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `No results found for '${query}' in Value Proposition Canvas.`,
+          },
+        ],
+      };
+    }
+
+    const text = results
+      .map((r) => `**[${r.segment}] ${r.type.toUpperCase()}:** ${r.text}`)
+      .join("\n\n");
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `# VPC Search Results for '${query}'\n\n${text}`,
+        },
+      ],
+    };
+  }
+
+  private parseSegments(vpcContent: string): VPCSegment[] {
+    const segments: VPCSegment[] = [];
+    const segmentRegex = /## Segment: (.+?)\n/g;
+    
+    let match;
+    const segmentStarts: Array<{ name: string; index: number }> = [];
+    
+    while ((match = segmentRegex.exec(vpcContent)) !== null) {
+      segmentStarts.push({ name: match[1], index: match.index });
+    }
+
+    for (let i = 0; i < segmentStarts.length; i++) {
+      const start = segmentStarts[i];
+      const end = i + 1 < segmentStarts.length ? segmentStarts[i + 1].index : vpcContent.length;
+      const segmentContent = vpcContent.slice(start.index, end);
+
+      segments.push({
+        name: start.name,
+        customerJobs: this.extractList(segmentContent, "#### Customer Jobs"),
+        pains: this.extractList(segmentContent, "#### Pains"),
+        gains: this.extractList(segmentContent, "#### Gains"),
+      });
+    }
+
+    return segments;
+  }
+
+  private extractList(content: string, heading: string): string[] {
+    const headingIndex = content.indexOf(heading);
+    if (headingIndex === -1) return [];
+
+    const afterHeading = content.slice(headingIndex + heading.length);
+    const nextHeadingIndex = afterHeading.search(/####|###|##/);
+    const section = nextHeadingIndex === -1 
+      ? afterHeading 
+      : afterHeading.slice(0, nextHeadingIndex);
+
+    const lines = section.split("\n");
+    const items: string[] = [];
+
+    for (const line of lines) {
+      const match = line.match(/^\d+\.\s+\*\*(.+?)\*\*\s*—\s*(.+)/);
+      if (match) {
+        items.push(`${match[1]} — ${match[2]}`);
+      }
+    }
+
+    return items;
+  }
+}

package/mcp-server/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schilling.mark.a/software-methodology",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Comprehensive software development methodology from product strategy through production deployment. Eleven skills covering Business Model Canvas, UX research, story mapping, BDD/ATDD, clean code, CI/CD, and continuous improvement.",
   "keywords": [
     "methodology",
@@ -16,7 +16,8 @@
     "cicd",
     "continuous-improvement",
     "claude-code",
-    "github-copilot"
+    "github-copilot",
+    "mcp-server"
   ],
   "author": "Mark Schilling",
   "repository": {
@@ -28,9 +29,14 @@
   "bugs": {
     "url": "https://github.com/MarkSchilling/software-methodology/issues"
   },
+  "workspaces": [
+    "mcp-server"
+  ],
   "files": [
     "dist/",
     "docs/",
+    "features/",
+    "mcp-server/",
     "project-templates/",
     ".github/copilot-instructions.md",
     "README.md",