specweave 0.18.0 → 0.20.0

package/plugins/specweave/skills/smart-reopen-detector/SKILL.md

@@ -0,0 +1,244 @@
+---
+name: smart-reopen-detector
+description: |
+  Detects when user reports issues with recently completed work and suggests reopening relevant tasks, user stories, or increments. Auto-activates on keywords: not working, broken, bug, issue, problem, failing, error, crash, regression, still broken, incorrect, missing, wrong. Scans active and recently completed (7 days) work to find related items. Provides smart suggestions with relevance scoring.
+---
+
+# Smart Reopen Detector
+
+## Purpose
+
+When you report an issue with recently completed work, I'll automatically:
+1. 🔍 **Scan your recent work** (active + completed in last 7 days)
+2. 🎯 **Identify related items** using keyword matching
+3. 💡 **Suggest what to reopen** with relevance scoring
+4. ⚠️  **Check WIP limits** before suggesting reopen
+
+## When I Activate
+
+I automatically activate when you mention these keywords:
+- **Not working**: "not working", "broken", "failing", "error", "crash"
+- **Quality issues**: "bug", "issue", "problem", "wrong", "incorrect", "missing"
+- **Regressions**: "still broken", "regression", "broken again", "came back"
+
+## How I Help
+
+### Example 1: Issue Report
+```
+User: "The GitHub sync isn't working, it was just completed yesterday"
+```
+
+I'll respond with:
+```
+🔍 Scanning recent work...
+
+Found 2 related item(s) in recent work:
+
+📦 INCREMENT: 0031-external-tool-status-sync
+   Increment: 0031-external-tool-status-sync
+   Completed: 2 days ago
+   Relevance: 15 points
+   Matched: github, sync
+
+✓ TASK: T-003 GitHub Content Sync
+   Increment: 0031-external-tool-status-sync
+   Completed: 1 day ago
+   Relevance: 14 points
+   Matched: github, sync
+
+💡 Suggested action:
+   /specweave:reopen 0031-external-tool-status-sync --reason "GitHub sync not working"
+
+Would you like me to:
+1. Reopen the entire increment (checks WIP limits)
+2. Reopen just task T-003 (targeted fix)
+3. Show me the WIP status first
+```
+
+### Example 2: Specific Feature Broken
+```
+User: "The authentication is broken after the recent deployment"
+```
+
+I'll respond with:
+```
+🔍 Scanning recent work...
+
+Found 3 related item(s) in recent work:
+
+✓ TASK: T-012 Authentication Service
+   Increment: 0025-user-auth
+   Completed: 3 days ago
+   Relevance: 10 points
+   Matched: authentication
+
+✓ TASK: T-014 JWT Token Validation
+   Increment: 0025-user-auth
+   Completed: 3 days ago
+   Relevance: 7 points
+   Matched: authentication
+
+💡 Suggested action:
+   /specweave:reopen 0025-user-auth --task T-012 --reason "Authentication broken after deployment"
+
+⚠️  Note: Increment 0025 was completed 3 days ago. Consider checking deployment config first.
+```
+
+### Example 3: No Recent Work Found
+```
+User: "The payment flow is not working"
+```
+
+I'll respond with:
+```
+🔍 Scanning recent work...
+
+🔍 No related work found in recent activity (last 7 days)
+
+The payment functionality might be:
+1. From an older increment (>7 days ago)
+2. Not yet implemented
+3. Part of external dependencies
+
+Would you like me to:
+1. Search all increments (not just recent)
+2. Create a new bug increment for investigation
+3. Check the backlog for related work
+```
+
+## What I Do
+
+### Step 1: Extract Keywords
+From your message, I extract relevant keywords:
+- Feature names (authentication, github, payment)
+- Action words (sync, deploy, validate)
+- Component names (api, database, frontend)
+
+### Step 2: Scan Recent Work
+I scan:
+- ✅ **Active increments** (currently being worked on)
+- ✅ **Recently completed** (last 7 days)
+- ✅ **All tasks** from these increments
+
+### Step 3: Score Matches
+I assign relevance scores using:
+- **+10 points**: Exact match in title/ID
+- **+7 points**: Partial match in title
+- **+5 points**: Match in increment ID
+- **+3 points**: Match in description/AC
+
+### Step 4: Suggest Actions
+I provide:
+- Top matches (up to 5)
+- Relevance scores
+- Suggested `/specweave:reopen` command
+- WIP limit warnings (if applicable)
+
+## Smart Suggestions
+
+### For Increments
+```bash
+# Reopen entire increment
+/specweave:reopen 0031-external-tool-status-sync --reason "GitHub sync failing"
+
+# Check WIP limits first (recommended)
+/specweave:status
+```
+
+### For Specific Tasks
+```bash
+# Reopen single task (surgical fix)
+/specweave:reopen 0031 --task T-003 --reason "GitHub API 500 error"
+
+# Reopen multiple related tasks
+/specweave:reopen 0031 --user-story US-001 --reason "All GitHub features broken"
+```
+
+### Force Reopen (Bypass WIP Limits)
+```bash
+# Use --force for critical production issues
+/specweave:reopen 0031 --force --reason "Production down, critical fix needed"
+```
+
+## WIP Limit Awareness
+
+Before suggesting increment reopen, I check:
+- ✅ Current active increment count
+- ✅ Type-specific limits (feature: 2, refactor: 1, etc.)
+- ⚠️  Warn if reopening will exceed limits
+
+**Example Warning**:
+```
+⚠️  WIP LIMIT WARNING:
+   Current active: 2 features
+   Limit: 2 features
+   Reopening 0031-external-tool-status-sync will EXCEED the limit!
+
+   Options:
+   1. Pause another feature first: /specweave:pause 0030
+   2. Complete another feature: /specweave:done 0029
+   3. Force reopen (not recommended): --force
+```
+
+## Integration with Commands
+
+I work seamlessly with:
+- `/specweave:reopen` - Execute reopen action
+- `/specweave:status` - Check WIP limits
+- `/specweave:progress` - See increment progress
+- `/specweave:pause` - Pause another increment to make room
+
+## When NOT to Use
+
+I don't activate for:
+- ❌ General questions about code
+- ❌ Feature requests (use `/specweave:increment`)
+- ❌ Documentation questions
+- ❌ Status inquiries (use `/specweave:status`)
+
+I **only** activate when you explicitly report something is broken/not working.
+
+## Technical Implementation
+
+**Core Logic**:
+- Uses `RecentWorkScanner` to find matches
+- Keyword extraction from user message
+- Relevance scoring algorithm
+- WIP limit validation before suggestions
+
+**Smart Features**:
+- Deduplication (same increment from active + recent)
+- Recency bias (prefer more recent completions)
+- Contextual hints (deployment, config, dependencies)
+
+## Examples of Activation
+
+### ✅ Will Activate
+- "GitHub sync not working"
+- "Authentication is broken"
+- "Tests are failing after the last commit"
+- "Deployment crashed"
+- "API returns 500 error"
+- "Still broken after the fix"
+
+### ❌ Won't Activate
+- "How does GitHub sync work?"
+- "Can you add authentication?"
+- "What's the status of increment 0031?"
+- "Show me the progress"
+- "Create a new feature for payments"
+
+## Success Metrics
+
+I'm successful when:
+- ✅ You find the related work quickly (<30 seconds)
+- ✅ The suggested reopen command is correct
+- ✅ No false positives (only relevant matches)
+- ✅ WIP limits are respected
+- ✅ Clear next steps provided
+
+---
+
+**Auto-loads when**: You report issues with recently completed work
+**Commands**: `/specweave:reopen`, `/specweave:status`
+**Related Skills**: `increment-planner`, `tdd-workflow`

package/plugins/specweave-ado/lib/ado-spec-content-sync.js

@@ -4,8 +4,9 @@ import {
   hasExternalLink,
   updateSpecWithExternalLink
 } from "../../../src/core/spec-content-sync.js";
-import path from "path";
-import fs from "fs/promises";
+import { SpecIncrementMapper } from "../../../src/core/sync/spec-increment-mapper.js";
+import * as path from "path";
+import * as fs from "fs/promises";
 async function syncSpecContentToAdo(options) {
   const { specPath, client, dryRun = false, verbose = false } = options;
   try {
@@ -44,8 +45,9 @@ async function syncSpecContentToAdo(options) {
 async function createAdoFeature(client, spec, options) {
   const { specPath, dryRun, verbose } = options;
   try {
+    const tasks = await getTaskMappings(specPath, spec.id);
     const title = `[${spec.id.toUpperCase()}] ${spec.title}`;
-    const description = buildAdoDescription(spec);
+    const description = buildAdoDescription(spec, tasks);
     if (verbose) {
       console.log(`
 \u{1F4DD} Creating ADO feature:`);
@@ -125,8 +127,9 @@ async function updateAdoFeature(client, spec, workItemId, options) {
         console.log(`      - ${change}`);
       }
     }
+    const tasks = await getTaskMappings(specPath, spec.id);
     const newTitle = `[${spec.id.toUpperCase()}] ${spec.title}`;
-    const newDescription = buildAdoDescription(spec);
+    const newDescription = buildAdoDescription(spec, tasks);
     if (dryRun) {
       console.log("\n\u{1F50D} Dry run - would update feature:");
       console.log(`   Title: ${newTitle}`);
@@ -160,7 +163,7 @@ ${newDescription}`);
     };
   }
 }
-function buildAdoDescription(spec) {
+function buildAdoDescription(spec, tasks) {
   let html = "";
   if (spec.description) {
     html += `<p>${escapeHtml(spec.description)}</p>`;
@@ -179,11 +182,52 @@ function buildAdoDescription(spec) {
       }
     }
   }
+  if (tasks && tasks.length > 0) {
+    html += "<h2>Implementation Tasks</h2>";
+    html += "<ul>";
+    for (const task of tasks) {
+      html += `<li><strong>${task.id}</strong>: ${escapeHtml(task.title)}`;
+      if (task.userStories && task.userStories.length > 0) {
+        html += ` (${task.userStories.join(", ")})`;
+      }
+      html += "</li>";
+    }
+    html += "</ul>";
+  }
   if (spec.metadata.priority) {
     html += `<p><strong>Priority:</strong> ${spec.metadata.priority}</p>`;
   }
   return html;
 }
+async function getTaskMappings(specPath, specId) {
+  try {
+    const rootDir = await findSpecWeaveRoot(specPath);
+    const mapper = new SpecIncrementMapper(rootDir);
+    const mapping = await mapper.mapSpecToIncrements(specId);
+    if (mapping.increments.length > 0) {
+      return mapping.increments[0].tasks;
+    }
+    return void 0;
+  } catch (error) {
+    return void 0;
+  }
+}
+async function findSpecWeaveRoot(specPath) {
+  let currentDir = path.dirname(specPath);
+  while (true) {
+    const specweaveDir = path.join(currentDir, ".specweave");
+    try {
+      await fs.access(specweaveDir);
+      return currentDir;
+    } catch {
+      const parentDir = path.dirname(currentDir);
+      if (parentDir === currentDir) {
+        throw new Error(".specweave directory not found");
+      }
+      currentDir = parentDir;
+    }
+  }
+}
 function escapeHtml(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
 }

package/plugins/specweave-ado/lib/ado-spec-content-sync.ts

@@ -20,8 +20,9 @@ import {
   ContentSyncResult,
 } from '../../../src/core/spec-content-sync.js';
 import { SyncProfile } from '../../../src/core/types/sync-profile.js';
-import path from 'path';
-import fs from 'fs/promises';
+import { SpecIncrementMapper, TaskInfo } from '../../../src/core/sync/spec-increment-mapper.js';
+import * as path from 'path';
+import * as fs from 'fs/promises';
 
 export interface AdoContentSyncOptions {
   specPath: string;
@@ -91,9 +92,12 @@ async function createAdoFeature(
   const { specPath, dryRun, verbose } = options;
 
   try {
+    // Get task mappings (if available)
+    const tasks = await getTaskMappings(specPath, spec.id);
+
     // Build feature title and description
     const title = `[${spec.id.toUpperCase()}] ${spec.title}`;
-    const description = buildAdoDescription(spec);
+    const description = buildAdoDescription(spec, tasks);
 
     if (verbose) {
       console.log(`\n📝 Creating ADO feature:`);
@@ -196,9 +200,12 @@ async function updateAdoFeature(
       }
     }
 
+    // Get task mappings (if available)
+    const tasks = await getTaskMappings(specPath, spec.id);
+
     // Build updated content
     const newTitle = `[${spec.id.toUpperCase()}] ${spec.title}`;
-    const newDescription = buildAdoDescription(spec);
+    const newDescription = buildAdoDescription(spec, tasks);
 
     if (dryRun) {
       console.log('\n🔍 Dry run - would update feature:');
@@ -242,10 +249,10 @@ async function updateAdoFeature(
 }
 
 /**
- * Build ADO description from spec content
+ * Build ADO description from spec content with optional task mappings
  * ADO supports HTML in description
  */
-function buildAdoDescription(spec: SpecContent): string {
+function buildAdoDescription(spec: SpecContent, tasks?: TaskInfo[]): string {
   let html = '';
 
   // Add spec description
@@ -271,6 +278,20 @@ function buildAdoDescription(spec: SpecContent): string {
     }
   }
 
+  // Add task mappings (if provided)
+  if (tasks && tasks.length > 0) {
+    html += '<h2>Implementation Tasks</h2>';
+    html += '<ul>';
+    for (const task of tasks) {
+      html += `<li><strong>${task.id}</strong>: ${escapeHtml(task.title)}`;
+      if (task.userStories && task.userStories.length > 0) {
+        html += ` (${task.userStories.join(', ')})`;
+      }
+      html += '</li>';
+    }
+    html += '</ul>';
+  }
+
   // Add metadata
   if (spec.metadata.priority) {
     html += `<p><strong>Priority:</strong> ${spec.metadata.priority}</p>`;
@@ -279,6 +300,51 @@ function buildAdoDescription(spec: SpecContent): string {
   return html;
 }
 
+/**
+ * Get task mappings for a spec (if available)
+ */
+async function getTaskMappings(specPath: string, specId: string): Promise<TaskInfo[] | undefined> {
+  try {
+    // Find SpecWeave root
+    const rootDir = await findSpecWeaveRoot(specPath);
+
+    // Use SpecIncrementMapper to get task mappings
+    const mapper = new SpecIncrementMapper(rootDir);
+    const mapping = await mapper.mapSpecToIncrements(specId);
+
+    if (mapping.increments.length > 0) {
+      // Return tasks from the first (most recent) increment
+      return mapping.increments[0].tasks;
+    }
+
+    return undefined;
+  } catch (error) {
+    // If mapping fails, just return undefined (not critical)
+    return undefined;
+  }
+}
+
+/**
+ * Find SpecWeave root directory from spec path
+ */
+async function findSpecWeaveRoot(specPath: string): Promise<string> {
+  let currentDir = path.dirname(specPath);
+
+  while (true) {
+    const specweaveDir = path.join(currentDir, '.specweave');
+    try {
+      await fs.access(specweaveDir);
+      return currentDir;
+    } catch {
+      const parentDir = path.dirname(currentDir);
+      if (parentDir === currentDir) {
+        throw new Error('.specweave directory not found');
+      }
+      currentDir = parentDir;
+    }
+  }
+}
+
 /**
  * Escape HTML special characters
  */

package/plugins/specweave-ado/lib/enhanced-ado-sync.js

@@ -0,0 +1,170 @@
+import { AdoClientV2 } from "./ado-client-v2.js";
+import { EnhancedContentBuilder } from "../../../src/core/sync/enhanced-content-builder.js";
+import { SpecIncrementMapper } from "../../../src/core/sync/spec-increment-mapper.js";
+import { parseSpecContent } from "../../../src/core/spec-content-sync.js";
+import path from "path";
+import fs from "fs/promises";
+async function syncSpecToAdoWithEnhancedContent(options) {
+  const { specPath, organization, project, dryRun = false, verbose = false } = options;
+  try {
+    const baseSpec = await parseSpecContent(specPath);
+    if (!baseSpec) {
+      return {
+        success: false,
+        action: "error",
+        error: "Failed to parse spec content"
+      };
+    }
+    if (verbose) {
+      console.log(`\u{1F4C4} Parsed spec: ${baseSpec.identifier.compact}`);
+    }
+    const specId = baseSpec.identifier.full || baseSpec.identifier.compact;
+    const rootDir = await findSpecWeaveRoot(specPath);
+    const mapper = new SpecIncrementMapper(rootDir);
+    const mapping = await mapper.mapSpecToIncrements(specId);
+    if (verbose) {
+      console.log(`\u{1F517} Found ${mapping.increments.length} related increments`);
+    }
+    const taskMapping = buildTaskMapping(mapping.increments, organization, project);
+    const architectureDocs = await findArchitectureDocs(rootDir, specId);
+    const enhancedSpec = {
+      ...baseSpec,
+      summary: baseSpec.description,
+      taskMapping,
+      architectureDocs
+    };
+    const builder = new EnhancedContentBuilder();
+    const description = builder.buildExternalDescription(enhancedSpec);
+    if (verbose) {
+      console.log(`\u{1F4DD} Generated description: ${description.length} characters`);
+    }
+    if (dryRun) {
+      console.log("\u{1F50D} DRY RUN - Would create/update feature with:");
+      console.log(`   Title: ${baseSpec.title}`);
+      console.log(`   Description length: ${description.length}`);
+      return {
+        success: true,
+        action: "no-change",
+        tasksLinked: taskMapping?.tasks.length || 0
+      };
+    }
+    if (!organization || !project) {
+      return {
+        success: false,
+        action: "error",
+        error: "Azure DevOps organization/project not specified"
+      };
+    }
+    const profile = {
+      provider: "ado",
+      displayName: `${organization}/${project}`,
+      config: {
+        organization,
+        project
+      },
+      timeRange: { default: "1M", max: "6M" }
+    };
+    const pat = process.env.AZURE_DEVOPS_PAT || "";
+    const client = new AdoClientV2(profile, pat);
+    const existingFeature = await findExistingFeature(client, baseSpec.identifier.compact);
+    let result;
+    if (existingFeature) {
+      await client.updateWorkItem(existingFeature.id, {
+        title: `[${baseSpec.identifier.compact}] ${baseSpec.title}`,
+        description
+      });
+      result = {
+        success: true,
+        action: "updated",
+        featureId: existingFeature.id,
+        featureUrl: `https://dev.azure.com/${organization}/${project}/_workitems/edit/${existingFeature.id}`,
+        tasksLinked: taskMapping?.tasks.length || 0
+      };
+    } else {
+      const feature = await client.createEpic({
+        title: `[${baseSpec.identifier.compact}] ${baseSpec.title}`,
+        description,
+        tags: ["spec", "external-tool-sync"]
+      });
+      result = {
+        success: true,
+        action: "created",
+        featureId: feature.id,
+        featureUrl: `https://dev.azure.com/${organization}/${project}/_workitems/edit/${feature.id}`,
+        tasksLinked: taskMapping?.tasks.length || 0
+      };
+    }
+    if (verbose) {
+      console.log(`\u2705 ${result.action === "created" ? "Created" : "Updated"} feature #${result.featureId}`);
+    }
+    return result;
+  } catch (error) {
+    return {
+      success: false,
+      action: "error",
+      error: error.message
+    };
+  }
+}
+async function findSpecWeaveRoot(specPath) {
+  let currentDir = path.dirname(specPath);
+  while (true) {
+    const specweaveDir = path.join(currentDir, ".specweave");
+    try {
+      await fs.access(specweaveDir);
+      return currentDir;
+    } catch {
+      const parentDir = path.dirname(currentDir);
+      if (parentDir === currentDir) {
+        throw new Error(".specweave directory not found");
+      }
+      currentDir = parentDir;
+    }
+  }
+}
+function buildTaskMapping(increments, organization, project) {
+  if (increments.length === 0) return void 0;
+  const firstIncrement = increments[0];
+  const tasks = firstIncrement.tasks.map((task) => ({
+    id: task.id,
+    title: task.title,
+    userStories: task.userStories
+  }));
+  return {
+    incrementId: firstIncrement.id,
+    tasks,
+    tasksUrl: `https://dev.azure.com/${organization}/${project}/_git/repo?path=/.specweave/increments/${firstIncrement.id}/tasks.md`
+  };
+}
+async function findArchitectureDocs(rootDir, specId) {
+  const docs = [];
+  const archDir = path.join(rootDir, ".specweave/docs/internal/architecture");
+  try {
+    const adrDir = path.join(archDir, "adr");
+    try {
+      const adrs = await fs.readdir(adrDir);
+      const relatedAdrs = adrs.filter((file) => file.includes(specId.replace("spec-", "")));
+      for (const adr of relatedAdrs) {
+        docs.push({
+          type: "adr",
+          path: path.join(adrDir, adr),
+          title: adr.replace(".md", "").replace(/-/g, " ")
+        });
+      }
+    } catch {
+    }
+  } catch {
+  }
+  return docs;
+}
+async function findExistingFeature(client, specId) {
+  try {
+    const features = await client.queryWorkItems(`[System.Title] Contains '[${specId}]' AND [System.WorkItemType] = 'Feature'`);
+    return features[0] || null;
+  } catch {
+    return null;
+  }
+}
+export {
+  syncSpecToAdoWithEnhancedContent
+};

package/plugins/specweave-confluent/.claude-plugin/plugin.json

@@ -0,0 +1,23 @@
+{
+  "name": "specweave-confluent",
+  "description": "Confluent Cloud integration for SpecWeave - Schema Registry, ksqlDB, Kafka Connect, Flink, stream processing, and enterprise Kafka features",
+  "version": "1.0.0",
+  "author": {
+    "name": "SpecWeave Team",
+    "url": "https://spec-weave.com"
+  },
+  "repository": "https://github.com/anton-abyzov/specweave",
+  "homepage": "https://spec-weave.com/docs/plugins/confluent",
+  "license": "MIT",
+  "keywords": [
+    "kafka",
+    "confluent",
+    "schema-registry",
+    "ksqldb",
+    "kafka-connect",
+    "flink",
+    "stream-processing",
+    "avro",
+    "protobuf"
+  ]
+}