specweave 0.4.0 → 0.6.0

package/src/adapters/generic/adapter.ts

@@ -12,6 +12,9 @@ import * as path from 'path';
 import fs from 'fs-extra';
 import { AdapterBase } from '../adapter-base.js';
 import { AdapterOptions, AdapterFile } from '../adapter-interface.js';
+import type { Plugin } from '../../core/types/plugin.js';
+import { LanguageManager, getSystemPromptForLanguage } from '../../core/i18n/language-manager.js';
+import type { SupportedLanguage } from '../../core/i18n/types.js';
 
 export class GenericAdapter extends AdapterBase {
   name = 'generic';
@@ -160,4 +163,197 @@ You're ready to build with SpecWeave using ANY AI tool!
 Remember: AGENTS.md is the universal standard - it works everywhere!
     `;
   }
+
+  /**
+   * Check if Generic adapter supports plugins
+   *
+   * Generic has manual plugin support via AGENTS.md
+   *
+   * @returns boolean True
+   */
+  supportsPlugins(): boolean {
+    return true;
+  }
+
+  /**
+   * Read language configuration from project config
+   *
+   * @returns Language setting from config, defaults to 'en'
+   */
+  private async getLanguageConfig(): Promise<SupportedLanguage> {
+    const projectPath = process.cwd();
+    const configPath = path.join(projectPath, '.specweave', 'config.json');
+
+    if (!(await fs.pathExists(configPath))) {
+      return 'en'; // Default to English if no config
+    }
+
+    try {
+      const config = await fs.readJson(configPath);
+      return (config.language as SupportedLanguage) || 'en';
+    } catch (error) {
+      console.warn('⚠️  Could not read language from config, defaulting to English');
+      return 'en';
+    }
+  }
+
+  /**
+   * Inject system prompt for non-English languages
+   *
+   * Prepends language instruction to markdown content if language !== 'en'
+   *
+   * @param content Original markdown content
+   * @param language Target language
+   * @returns Modified content with system prompt (or unchanged if English)
+   */
+  private injectSystemPrompt(content: string, language: SupportedLanguage): string {
+    if (language === 'en') {
+      return content; // No changes for English - preserve default behavior
+    }
+
+    // Get system prompt for target language
+    const systemPrompt = getSystemPromptForLanguage(language);
+
+    // For AGENTS.md compilation, inject at the beginning of the content
+    return `${systemPrompt}\n\n${content}`;
+  }
+
+  /**
+   * Compile and install a plugin for Generic adapter
+   *
+   * Appends plugin content to AGENTS.md for manual copy-paste workflows
+   *
+   * NEW: Injects system prompts for non-English languages
+   *
+   * @param plugin Plugin to install
+   */
+  async compilePlugin(plugin: Plugin): Promise<void> {
+    const projectPath = process.cwd();
+    const agentsMdPath = path.join(projectPath, 'AGENTS.md');
+
+    console.log(`\n📦 Adding plugin to AGENTS.md: ${plugin.manifest.name}`);
+
+    // Get language configuration for system prompt injection
+    const language = await this.getLanguageConfig();
+    if (language !== 'en') {
+      console.log(`   🌐 Language: ${language} (system prompts will be injected)`);
+    }
+
+    if (!(await fs.pathExists(agentsMdPath))) {
+      throw new Error('AGENTS.md not found. Run specweave init first.');
+    }
+
+    let agentsMd = await fs.readFile(agentsMdPath, 'utf-8');
+
+    const pluginMarker = `<!-- Plugin: ${plugin.manifest.name} -->`;
+    if (agentsMd.includes(pluginMarker)) {
+      console.log(`   ℹ️  Plugin ${plugin.manifest.name} already in AGENTS.md`);
+      return;
+    }
+
+    let pluginSection = `\n\n${pluginMarker}\n\n`;
+    pluginSection += `# Plugin: ${plugin.manifest.name}\n\n`;
+    pluginSection += `${plugin.manifest.description}\n\n`;
+
+    if (plugin.skills.length > 0) {
+      pluginSection += `## Skills\n\n`;
+      for (const skill of plugin.skills) {
+        const skillContent = await fs.readFile(path.join(skill.path, 'SKILL.md'), 'utf-8');
+        const contentWithoutFrontmatter = skillContent.replace(/^---\n[\s\S]+?\n---\n/, '');
+        // Inject system prompt if needed
+        const modifiedContent = this.injectSystemPrompt(contentWithoutFrontmatter, language);
+        pluginSection += `### ${skill.name}\n\n${modifiedContent}\n\n`;
+      }
+    }
+
+    if (plugin.agents.length > 0) {
+      pluginSection += `## Agents\n\n`;
+      for (const agent of plugin.agents) {
+        const agentContent = await fs.readFile(path.join(agent.path, 'AGENT.md'), 'utf-8');
+        // Inject system prompt if needed
+        const modifiedContent = this.injectSystemPrompt(agentContent, language);
+        pluginSection += `### ${agent.name}\n\n${modifiedContent}\n\n`;
+      }
+    }
+
+    if (plugin.commands.length > 0) {
+      pluginSection += `## Workflows (Manual)\n\n`;
+      for (const command of plugin.commands) {
+        const commandContent = await fs.readFile(command.path, 'utf-8');
+        const contentWithoutFrontmatter = commandContent.replace(/^---\n[\s\S]+?\n---\n/, '');
+        // Inject system prompt if needed
+        const modifiedContent = this.injectSystemPrompt(contentWithoutFrontmatter, language);
+        pluginSection += `### ${command.name.replace('specweave.', '')}\n\n${modifiedContent}\n\n`;
+      }
+    }
+
+    pluginSection += `<!-- End Plugin: ${plugin.manifest.name} -->\n`;
+
+    agentsMd += pluginSection;
+    await fs.writeFile(agentsMdPath, agentsMd, 'utf-8');
+
+    console.log(`   ✓ Added to AGENTS.md (copy-paste workflows)`);
+    console.log(`\n✅ Plugin ${plugin.manifest.name} available for manual use!`);
+  }
+
+  /**
+   * Unload a plugin from Generic adapter
+   */
+  async unloadPlugin(pluginName: string): Promise<void> {
+    const projectPath = process.cwd();
+    const agentsMdPath = path.join(projectPath, 'AGENTS.md');
+
+    console.log(`\n🗑️  Removing plugin from AGENTS.md: ${pluginName}`);
+
+    if (!(await fs.pathExists(agentsMdPath))) {
+      console.warn(`⚠️  AGENTS.md not found`);
+      return;
+    }
+
+    let agentsMd = await fs.readFile(agentsMdPath, 'utf-8');
+
+    const startMarker = `<!-- Plugin: ${pluginName} -->`;
+    const endMarker = `<!-- End Plugin: ${pluginName} -->`;
+
+    const startIndex = agentsMd.indexOf(startMarker);
+    if (startIndex === -1) {
+      console.warn(`⚠️  Plugin ${pluginName} not found in AGENTS.md`);
+      return;
+    }
+
+    const endIndex = agentsMd.indexOf(endMarker, startIndex);
+    if (endIndex === -1) {
+      console.warn(`⚠️  Plugin ${pluginName} section malformed`);
+      return;
+    }
+
+    agentsMd = agentsMd.slice(0, startIndex) + agentsMd.slice(endIndex + endMarker.length);
+    await fs.writeFile(agentsMdPath, agentsMd, 'utf-8');
+
+    console.log(`   ✓ Removed from AGENTS.md`);
+    console.log(`\n✅ Plugin ${pluginName} removed!`);
+  }
+
+  /**
+   * Get list of installed plugins for Generic adapter
+   */
+  async getInstalledPlugins(): Promise<string[]> {
+    const projectPath = process.cwd();
+    const agentsMdPath = path.join(projectPath, 'AGENTS.md');
+
+    if (!(await fs.pathExists(agentsMdPath))) {
+      return [];
+    }
+
+    const agentsMd = await fs.readFile(agentsMdPath, 'utf-8');
+    const pluginMarkerRegex = /<!-- Plugin: (specweave-[a-z0-9-]+) -->/g;
+    const matches = agentsMd.matchAll(pluginMarkerRegex);
+
+    const plugins: string[] = [];
+    for (const match of matches) {
+      plugins.push(match[1]);
+    }
+
+    return plugins;
+  }
 }

package/src/templates/AGENTS.md.template

@@ -45,12 +45,166 @@ This is a **SpecWeave project** where specifications and documentation are the s
 ├── agents/                  # Specialized roles (PM, Architect, DevOps, etc.)
 ├── skills/                  # Capabilities (increment-planner, context-loader, etc.)
 └── commands/                # Slash commands (/inc, /do, /done)
+
+plugins/                     # Optional plugins (extended capabilities)
+└── specweave-{name}/
+    ├── .claude-plugin/      # Plugin manifest (Claude native format)
+    │   └── plugin.json
+    ├── skills/              # Plugin-specific skills
+    ├── agents/              # Plugin-specific agents
+    └── commands/            # Plugin-specific commands
 ```
 
 **CRITICAL**: Always read `context-manifest.yaml` first! Only load files listed there.
 
 ---
 
+## 🔌 Plugin Architecture (IMPORTANT FOR NON-CLAUDE TOOLS)
+
+### For Claude Code Users
+
+Plugins work automatically via marketplace:
+```bash
+/plugin install github@specweave
+```
+
+Skills, agents, and commands are immediately available. **Skip this section if using Claude Code.**
+
+### For Other Tools (Cursor, Copilot, ChatGPT, etc.)
+
+**⚠️ CRITICAL**: Claude Code has native plugin support. **Other tools DO NOT.**
+
+You MUST manually discover and load plugins at the start of each session:
+
+#### Step 1: Check for Plugins
+
+```bash
+# Check if project uses plugins
+ls plugins/
+
+# Example output:
+# specweave-github/
+# specweave-jira/
+```
+
+If `plugins/` folder exists, proceed to Step 2.
+
+#### Step 2: Load Plugin Components
+
+**For EACH plugin, load its components BEFORE starting work:**
+
+```bash
+# Example: Loading GitHub plugin
+
+# 1. Check plugin structure
+ls plugins/specweave-github/
+
+# 2. Load ALL plugin skills (like core skills)
+cat plugins/specweave-github/skills/github-sync/SKILL.md
+cat plugins/specweave-github/skills/github-issue-tracker/SKILL.md
+
+# 3. Load plugin agents (if any)
+cat plugins/specweave-github/agents/github-manager/AGENT.md
+
+# 4. Note available commands (load on-demand when user requests)
+ls plugins/specweave-github/commands/
+# github-create-issue.md, github-sync.md, github-status.md
+```
+
+#### Step 3: Make Plugin Capabilities Available
+
+Treat plugin components like core components:
+
+**Plugin Skills**:
+- Same activation pattern as core skills
+- Check "Activates for" keywords in SKILL.md
+- Follow workflow when relevant
+
+**Plugin Agents**:
+- Adopt role when needed (like core agents)
+- Example: "Adopting github-manager agent role..."
+
+**Plugin Commands**:
+- Load command file when user requests action
+- Example: User says "sync to GitHub" → Load `plugins/specweave-github/commands/github-sync.md`
+
+#### Step 4: Document Loaded Plugins
+
+At session start, note which plugins are active:
+
+```markdown
+# Session Context
+- Core skills: ✅ Loaded from .claude/skills/
+- Core agents: ✅ Loaded from .claude/agents/
+- Plugins detected:
+  - specweave-github: ✅ Loaded (2 skills, 1 agent, 4 commands)
+  - specweave-jira: ✅ Loaded (1 skill, 1 agent, 2 commands)
+```
+
+### Why Manual Loading Is Required
+
+**Claude Code**: Has native plugin marketplace, auto-loads plugins, manages dependencies.
+
+**Other Tools**: No plugin system, so you must:
+- ✅ Discover plugins in `plugins/` folder
+- ✅ Read plugin skills/agents/commands manually
+- ✅ Make them available in your context
+- ✅ Use them like core components
+
+**This is NOT optional** - plugins extend SpecWeave capabilities. Without loading them, you're missing critical functionality (GitHub sync, Jira integration, tech-specific skills, etc.).
+
+### Example: Session Start Routine (Non-Claude Tools)
+
+```bash
+# 1. Load core components
+cat .claude/skills/SKILLS-INDEX.md  # Core skills index
+cat AGENTS.md                        # This file
+
+# 2. Check for plugins
+if [ -d "plugins" ]; then
+  # 3. For each plugin, load components
+  for plugin in plugins/*/; do
+    echo "Loading plugin: $(basename $plugin)"
+
+    # Load all skills
+    find "$plugin/skills" -name "SKILL.md" -exec cat {} \;
+
+    # Load all agents
+    find "$plugin/agents" -name "AGENT.md" -exec cat {} \;
+
+    # Note available commands
+    ls "$plugin/commands/"
+  done
+fi
+
+# 4. Now ready to work with full SpecWeave capabilities
+```
+
+### Plugin Naming Convention
+
+Plugin commands use namespace pattern:
+
+**Core commands** (no namespace):
+- `/specweave:inc` → Core framework
+- `/specweave:do` → Core framework
+- `/specweave:progress` → Core framework
+
+**Plugin commands** (with namespace):
+- `/specweave:github:sync` → GitHub plugin
+- `/specweave:github:create-issue` → GitHub plugin
+- `/specweave:jira:sync` → Jira plugin
+- `/specweave:jira:create-ticket` → Jira plugin
+
+**In non-Claude tools**: Read the command file when user requests the action:
+```bash
+# User: "Sync this increment to GitHub"
+# You: Load and execute command
+cat plugins/specweave-github/commands/github-sync.md
+# Then follow the instructions in that file
+```
+
+---
+
 ## Available Agents (Specialized Roles)
 
 SpecWeave uses role-based development. When working on tasks, adopt the appropriate role:
@@ -319,6 +473,7 @@ max_context_tokens: 10000
 
 If using Claude Code, these slash commands are available:
 
+**Core Commands** (always available):
 | Command | Purpose | Example |
 |---------|---------|---------|
 | `/inc` | Create new increment | `/inc "user authentication"` |
@@ -326,7 +481,21 @@ If using Claude Code, these slash commands are available:
 | `/progress` | Check status | `/progress` |
 | `/done` | Close increment | `/done 0001` |
 | `/validate` | Validate quality | `/validate 0001 --quality` |
-| `/sync-github` | Sync to GitHub | `/sync-github` |
+
+**Plugin Commands** (when plugin installed):
+| Command | Purpose | Plugin |
+|---------|---------|--------|
+| `/specweave:github:sync` | Sync to GitHub | specweave-github |
+| `/specweave:github:create-issue` | Create GitHub issue | specweave-github |
+| `/specweave:jira:sync` | Sync to Jira | specweave-jira |
+| `/specweave:jira:create-ticket` | Create Jira ticket | specweave-jira |
+
+**For non-Claude tools**: Read the command file when user requests the action:
+```bash
+# User: "Sync to GitHub"
+cat plugins/specweave-github/commands/github-sync.md
+# Then follow instructions in that file
+```
 
 ---
 

package/src/templates/CLAUDE.md.template

@@ -4,39 +4,83 @@ This project uses **SpecWeave** - a specification-first AI development framework
 
 ---
 
+## 🚨 CRITICAL: NEVER POLLUTE PROJECT ROOT!
+
+**⛔ THIS IS THE #1 RULE - ALL AI-GENERATED FILES GO IN INCREMENT FOLDERS ⛔**
+
+### ❌ NEVER Create in Root
+
+```
+❌ WRONG - ROOT FILES (NOT ALLOWED!):
+/SESSION-SUMMARY.md                    # NO! Goes to increment reports/
+/ANALYSIS-REPORT.md                    # NO! Goes to increment reports/
+/migration-script.py                   # NO! Goes to increment scripts/
+/execution.log                         # NO! Goes to increment logs/
+/temp-data.json                        # NO! Goes to increment logs/
+
+✅ CORRECT - INCREMENT FOLDERS:
+.specweave/increments/0001-user-auth/
+├── spec.md                            # Core spec files
+├── plan.md
+├── tasks.md
+├── tests.md
+├── reports/                           # ✅ PUT REPORTS HERE!
+│   ├── SESSION-SUMMARY.md
+│   └── ANALYSIS-REPORT.md
+├── scripts/                           # ✅ PUT SCRIPTS HERE!
+│   └── migration-script.py
+└── logs/                              # ✅ PUT LOGS HERE!
+    ├── execution.log
+    └── temp-data.json
+```
+
+### What IS Allowed in Root?
+
+**ONLY these files**:
+- ✅ `CLAUDE.md` (this file)
+- ✅ Your project files (`src/`, `package.json`, etc.)
+- ✅ Standard config (`.env`, `.gitignore`, `tsconfig.json`)
+
+**Everything else → increment folders!**
+
+**Before asking me to commit, check**: `git status` - If you see unexpected `.md` files in root, STOP and move them!
+
+---
+
 ## SpecWeave Workflow (Use These Commands!)
 
 **How SpecWeave works**:
 
 ```
-/specweave.inc "feature" → /specweave.do → /specweave.progress → /specweave.done → repeat
+/specweave:inc "feature" → /specweave:do → /specweave:progress → /specweave:done → repeat
 ```
 
-**1. Plan Feature** → `/specweave.inc "user authentication"`
+**1. Plan Feature** → `/specweave:inc "user authentication"`
    - Creates spec.md (WHAT/WHY), plan.md (HOW), tasks.md, tests.md
    - PM-led process with architect/security/QA review
    - **Use when**: Starting any new feature or increment
 
-**2. Execute Tasks** → `/specweave.do` or `/specweave.do 0001`
+**2. Execute Tasks** → `/specweave:do` or `/specweave:do 0001`
    - Smart resume (picks up where you left off)
    - Runs hooks after EVERY task completion
    - **Use when**: Ready to implement planned work
 
-**3. Check Progress** → `/specweave.progress`
+**3. Check Progress** → `/specweave:progress`
    - Shows task completion %, next action
    - **Use when**: Want to see status
 
-**4. Validate Quality** → `/specweave.validate 0001` or `/specweave.validate 0001 --quality`
+**4. Validate Quality** → `/specweave:validate 0001` or `/specweave:validate 0001 --quality`
    - Rule-based validation (120 checks)
    - Optional AI quality assessment
    - **Use when**: Verify increment quality before completion
 
-**5. Close Increment** → `/specweave.done 0001`
+**5. Close Increment** → `/specweave:done 0001`
    - Validates all tasks complete
    - **Use when**: Feature is finished
 
-**6. Sync to External** → `/specweave.sync-github` or `/specweave.sync-jira`
-   - Exports to GitHub issues or Jira
+**6. Sync to External** (Plugin Commands):
+   - `/specweave:github:sync` - Export to GitHub issues (github plugin)
+   - `/specweave:jira:sync` - Export to Jira (jira plugin)
    - **Use when**: Need to sync with project management tools
 
 **All other functionality (agents, skills) activates automatically based on context.**
@@ -60,7 +104,7 @@ When working in a SpecWeave-initialized project (`.specweave/` exists), SpecWeav
 6. ✅ **Business Model** - "Freemium", "$X/mo", "B2B", "Consumer"
 
 **Confidence Levels:**
-- **High (5-6 signals + SpecWeave folder)**: Auto-route to `/specweave.inc` immediately
+- **High (5-6 signals + SpecWeave folder)**: Auto-route to `/specweave:inc` immediately
 - **Medium (3-4 signals + SpecWeave folder)**: Ask 1-2 clarifying questions, then route
 - **Low (<3 signals)**: Regular conversation (no auto-routing)
 
@@ -80,7 +124,7 @@ Monetization: Freemium ($10/mo)
 SpecWeave detects: ✅ Name ✅ Features ✅ Tech ✅ Timeline ✅ Problem ✅ Business
 → Automatically recognizes this as a product description
 → Guides you through increment planning
-→ Invokes /specweave.inc automatically
+→ Invokes /specweave:inc automatically
 
 No need to remember to type /inc!
 ```
@@ -204,9 +248,9 @@ Config: Auto-detected from project files
 │   └── tests/                   # Centralized test repository
 │
 ├── .claude/                     # Pre-installed components
-│   ├── agents/                  # 10 agents (auto-activate)
-│   ├── skills/                  # 35+ skills (auto-activate)
-│   └── commands/                # Slash commands
+│   ├── agents/                  # Core + plugin agents (auto-activate)
+│   ├── skills/                  # Core + plugin skills (auto-activate)
+│   └── commands/                # Core + plugin slash commands
 │
 ├── CLAUDE.md                    # This file
 └── src/                         # Your source code
@@ -214,15 +258,67 @@ Config: Auto-detected from project files
 
 ---
 
+## Plugin Architecture
+
+**SpecWeave uses Claude Code's native plugin system** for optional capabilities.
+
+### Core vs. Plugins
+
+**Core Framework** (always loaded):
+- 9 core skills (increment-planner, tdd-workflow, context-loader, etc.)
+- 3 core agents (PM, Architect, Tech Lead)
+- 7 core commands (`/specweave:inc`, `/specweave:do`, etc.)
+- ~12K tokens (lightweight!)
+
+**Plugins** (opt-in based on your stack):
+- Tech stacks: `specweave-frontend`, `specweave-backend`, `specweave-kubernetes`
+- Integrations: `specweave-github`, `specweave-jira`
+- Domains: `specweave-ml`, `specweave-payments`, `specweave-testing`
+
+### Using Plugin Commands
+
+**Core commands** (always available):
+```bash
+/specweave:inc "feature"    # or /inc
+/specweave:do               # or /do
+/specweave:progress         # or /progress
+```
+
+**Plugin commands** (when plugin installed):
+```bash
+# GitHub plugin:
+/specweave:github:sync          # Sync increments to GitHub issues
+/specweave:github:create-issue  # Create new issue
+/specweave:github:status        # Check sync status
+
+# Jira plugin:
+/specweave:jira:sync           # Sync to Jira
+/specweave:jira:create-ticket  # Create Jira ticket
+```
+
+**Plugin agents and skills activate automatically** based on your tech stack and context.
+
+### Installing Plugins
+
+Plugins are detected and suggested during `specweave init` based on:
+- Git remote (GitHub detected → suggest github plugin)
+- Tech stack (React detected → suggest frontend plugin)
+- Project files (K8s yamls → suggest kubernetes plugin)
+
+**Enabled plugins**: {ENABLED_PLUGINS}
+
+---
+
 ## Documentation Philosophy
 
 **You chose**: {DOCUMENTATION_APPROACH}
 
 {#IF_COMPREHENSIVE}
 ### Comprehensive Upfront Approach
-- Create complete specifications before coding (500-600+ pages)
+- Create complete specifications before coding (scope-appropriate detail)
 - All ADRs documented in advance
-- Best for: Enterprise, regulated industries, large teams
+- Best for: Enterprise, regulated industries, large teams, complex systems
+- Spec size scales with project complexity (10-500+ pages depending on scope)
 {#ENDIF}
 
 {#IF_INCREMENTAL}
@@ -238,8 +334,8 @@ Config: Auto-detected from project files
 
 **Four Levels**:
 1. **Specification** (`.specweave/docs/internal/strategy/`) - Acceptance criteria
-2. **Feature** (`.specweave/increments/####/tests.md`) - Test coverage
-3. **Skill** (`src/skills/{name}/test-cases/`) - YAML test cases
+2. **Feature** (`.specweave/increments/####/tests.md`) - Test coverage per increment
+3. **Integration** (`tests/integration/` or `tests/specs/`) - Component/module tests
 4. **Code** (`tests/`) - Automated tests (Unit, Integration, E2E)
 
 **Requirements**:
@@ -260,16 +356,18 @@ Config: Auto-detected from project files
 | "What's the status?" | `/progress` | Show task completion % |
 | "Is this ready?" | `/validate 0001` | Validate increment quality |
 | "We're done" | `/done 0001` | Close increment |
-| "Sync to GitHub" | `/sync-github` | Export to GitHub issues |
-| "Sync to Jira" | `/sync-jira` | Export to Jira |
+
+**Plugin Commands** (when installed):
+| "Sync to GitHub" | `/specweave:github:sync` | Export to GitHub issues |
+| "Sync to Jira" | `/specweave:jira:sync` | Export to Jira |
 
 ### Command Aliases
 
-- `/inc` = `/specweave inc` = `/specweave.inc`
-- `/do` = `/specweave do` = `/specweave.do`
-- `/validate` = `/specweave validate` = `/specweave.validate`
-- `/done` = `/specweave done` = `/specweave.done`
-- `/progress` = `/specweave progress` = `/specweave.progress`
+- `/inc` = `/specweave inc` = `/specweave:inc`
+- `/do` = `/specweave do` = `/specweave:do`
+- `/validate` = `/specweave validate` = `/specweave:validate`
+- `/done` = `/specweave done` = `/specweave:done`
+- `/progress` = `/specweave progress` = `/specweave:progress`
 
 ---