specweave 0.1.9 → 0.3.0

package/dist/utils/esm-helpers.js

@@ -0,0 +1,57 @@
+/**
+ * ESM Helpers
+ *
+ * Provides __dirname and __filename equivalents for ES modules.
+ * In ESM, these CommonJS globals are not available, so we need to derive them
+ * from import.meta.url.
+ */
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+/**
+ * Get __dirname equivalent in ESM
+ *
+ * @param importMetaUrl - Pass import.meta.url from the calling module
+ * @returns The directory path of the calling module
+ *
+ * @example
+ * ```ts
+ * import { getDirname } from './utils/esm-helpers.js';
+ * const __dirname = getDirname(import.meta.url);
+ * ```
+ */
+export function getDirname(importMetaUrl) {
+    return dirname(fileURLToPath(importMetaUrl));
+}
+/**
+ * Get __filename equivalent in ESM
+ *
+ * @param importMetaUrl - Pass import.meta.url from the calling module
+ * @returns The file path of the calling module
+ *
+ * @example
+ * ```ts
+ * import { getFilename } from './utils/esm-helpers.js';
+ * const __filename = getFilename(import.meta.url);
+ * ```
+ */
+export function getFilename(importMetaUrl) {
+    return fileURLToPath(importMetaUrl);
+}
+/**
+ * Get both __dirname and __filename at once
+ *
+ * @param importMetaUrl - Pass import.meta.url from the calling module
+ * @returns Object with __dirname and __filename
+ *
+ * @example
+ * ```ts
+ * import { getFilePaths } from './utils/esm-helpers.js';
+ * const { __dirname, __filename } = getFilePaths(import.meta.url);
+ * ```
+ */
+export function getFilePaths(importMetaUrl) {
+    const __filename = fileURLToPath(importMetaUrl);
+    const __dirname = dirname(__filename);
+    return { __dirname, __filename };
+}
+//# sourceMappingURL=esm-helpers.js.map

package/dist/utils/esm-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"esm-helpers.js","sourceRoot":"","sources":["../../src/utils/esm-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,KAAK,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAE/B;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,UAAU,CAAC,aAAqB;IAC9C,OAAO,OAAO,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC;AAC/C,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,WAAW,CAAC,aAAqB;IAC/C,OAAO,aAAa,CAAC,aAAa,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,YAAY,CAAC,aAAqB;IAIhD,MAAM,UAAU,GAAG,aAAa,CAAC,aAAa,CAAC,CAAC;IAChD,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IACtC,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC;AACnC,CAAC"}

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "specweave",
-  "version": "0.1.9",
-  "description": "Replace vibe coding with spec-driven development. Smart workflow: /inc auto-closes previous, /build auto-resumes, /progress shows status. PM-led planning, 10 agents, 35+ skills. spec-weave.com",
+  "version": "0.3.0",
+  "description": "Replace vibe coding with spec-driven development. Smart workflow: /specweave inc auto-closes previous, /specweave build auto-resumes, /specweave progress shows status. PM-led planning, 10 agents, 35+ skills. spec-weave.com",
+  "type": "module",
   "main": "dist/index.js",
   "bin": {
     "specweave": "./bin/specweave.js"
@@ -13,7 +14,15 @@
     "test": "jest",
     "test:smoke": "bash tests/smoke/e2e-smoke-test.sh",
     "test:e2e": "playwright test tests/e2e/specweave-smoke.spec.ts",
-    "test:all": "npm test && npm run test:smoke",
+    "test:integration": "npm run test:integration:ado && npm run test:integration:jira",
+    "test:integration:ado": "ts-node tests/integration/ado-sync/ado-sync.test.ts",
+    "test:integration:jira": "ts-node tests/integration/jira-sync/jira-sync.test.ts",
+    "test:sync:jira": "ts-node tests/integration/jira-sync/jira-bidirectional-sync.test.ts",
+    "test:incremental:jira": "ts-node tests/integration/jira-sync/jira-incremental-sync.test.ts",
+    "generate:tests": "ts-node scripts/generate-tests.ts",
+    "generate:tests:skill": "ts-node scripts/generate-tests.ts",
+    "test:all:generated": "bash scripts/run-all-tests.sh",
+    "test:all": "npm test && npm run test:smoke && npm run test:integration",
     "prepublishOnly": "npm run build",
     "install:agents": "bash bin/install-agents.sh",
     "install:skills": "bash bin/install-skills.sh",
@@ -22,10 +31,8 @@
     "install:skills:global": "bash bin/install-skills.sh --global",
     "install:all:global": "bash bin/install-all.sh --global",
     "generate:diagrams": "bash scripts/generate-diagram-svgs.sh",
-    "docs:public": "cd docs-site && npm start",
-    "docs:internal": "mkdocs serve -f mkdocs-internal.yml",
-    "docs:build:public": "cd docs-site && npm run build",
-    "docs:build:internal": "mkdocs build -f mkdocs-internal.yml"
+    "docs:dev": "cd docs-site && npm start",
+    "docs:build": "cd docs-site && npm run build"
   },
   "keywords": [
     "specweave",
@@ -73,6 +80,7 @@
     "commander": "^11.1.0",
     "fs-extra": "^11.2.0",
     "inquirer": "^9.2.12",
+    "js-yaml": "^4.1.0",
     "ora": "^7.0.1",
     "yaml": "^2.3.4"
   },
@@ -82,6 +90,7 @@
     "@types/fs-extra": "^11.0.4",
     "@types/inquirer": "^9.0.7",
     "@types/jest": "^29.5.11",
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.10.0",
     "jest": "^29.7.0",
     "ts-jest": "^29.1.1",

package/src/adapters/README.md

@@ -12,7 +12,6 @@ SpecWeave adapters enable the framework to work with **ANY AI coding tool**, not
 SpecWeave
 ├── Core (Tool-Agnostic)
 │   └── .specweave/              # Plain Markdown + YAML
-│       ├── config.yaml
 │       ├── increments/
 │       └── docs/
 │
@@ -69,7 +68,7 @@ interface IAdapter {
 **Files Installed**:
 - `.claude/skills/` - Auto-activating skills (specweave-detector, skill-router, etc.)
 - `.claude/agents/` - Specialized agents (PM, Architect, DevOps, QA, Security)
-- `.claude/commands/` - Slash commands (/create-increment, /review-docs, etc.)
+- `.claude/commands/` - Slash commands (/create-increment, /sync-docs, etc.)
 - `.claude/hooks/` - Auto-update hooks (post-task-completion, etc.)
 
 **Features**:

package/src/adapters/adapter-base.ts

@@ -5,15 +5,19 @@
  * Concrete adapters extend this class and implement tool-specific logic.
  */
 
-import * as fs from 'fs-extra';
+import fs from 'fs-extra';
 import * as path from 'path';
+import { execSync } from 'child_process';
 import {
   IAdapter,
   AdapterOptions,
   RequirementsResult,
   AdapterFile,
   AutomationLevel
-} from './adapter-interface';
+} from './adapter-interface.js';
+import { getDirname } from '../utils/esm-helpers.js';
+
+const __dirname = getDirname(import.meta.url);
 
 export abstract class AdapterBase implements IAdapter {
   abstract name: string;
@@ -49,7 +53,6 @@ export abstract class AdapterBase implements IAdapter {
 
     // Check Git
     try {
-      const { execSync } = require('child_process');
       execSync('git --version', { stdio: 'ignore' });
     } catch (error) {
       result.warnings.push('Git not found - version control features may not work');

package/src/adapters/adapter-loader.ts

@@ -0,0 +1,261 @@
+/**
+ * Adapter Loader
+ *
+ * Loads adapters from registry, detects tools, and provides API for init command.
+ * Enables SpecWeave to work with ANY AI coding tool.
+ */
+
+import fs from 'fs-extra';
+import * as path from 'path';
+import * as YAML from 'yaml';
+import { execSync } from 'child_process';
+import { IAdapter } from './adapter-interface.js';
+import { CursorAdapter } from './cursor/adapter.js';
+import { CopilotAdapter } from './copilot/adapter.js';
+import { GeminiAdapter } from './gemini/adapter.js';
+import { CodexAdapter } from './codex/adapter.js';
+import { GenericAdapter } from './generic/adapter.js';
+import { getDirname } from '../utils/esm-helpers.js';
+
+const __dirname = getDirname(import.meta.url);
+
+export interface AdapterRegistry {
+  version: number;
+  last_updated: string;
+  adapters: Array<{
+    name: string;
+    description: string;
+    automation_level: string;
+    status: string;
+    directory: string;
+    market_share: string;
+    priority: string;
+  }>;
+}
+
+/**
+ * Adapter Loader - Main API for working with adapters
+ */
+export class AdapterLoader {
+  private adapters: Map<string, IAdapter> = new Map();
+  private registry: AdapterRegistry | null = null;
+
+  constructor() {
+    this.initializeAdapters();
+  }
+
+  /**
+   * Initialize all adapters
+   *
+   * NOTE: Claude Code is NOT an adapter - it's the native/default experience!
+   * Adapters only exist for tools that need to APPROXIMATE Claude's native capabilities.
+   */
+  private initializeAdapters(): void {
+    // Note: No ClaudeAdapter - Claude is the baseline, not an adaptation!
+    this.adapters.set('cursor', new CursorAdapter());
+    this.adapters.set('copilot', new CopilotAdapter());
+    this.adapters.set('gemini', new GeminiAdapter());
+    this.adapters.set('codex', new CodexAdapter());
+    this.adapters.set('generic', new GenericAdapter());
+  }
+
+  /**
+   * Load registry.yaml
+   */
+  async loadRegistry(): Promise<AdapterRegistry> {
+    if (this.registry) {
+      return this.registry;
+    }
+
+    // Try dist first, then fall back to src (for development)
+    let registryPath = path.join(__dirname, 'registry.yaml');
+    if (!await fs.pathExists(registryPath)) {
+      registryPath = path.join(__dirname, '../../src/adapters/registry.yaml');
+    }
+
+    const content = await fs.readFile(registryPath, 'utf-8');
+    this.registry = YAML.parse(content) as AdapterRegistry;
+
+    return this.registry;
+  }
+
+  /**
+   * Get all available adapters
+   */
+  getAllAdapters(): IAdapter[] {
+    return Array.from(this.adapters.values());
+  }
+
+  /**
+   * Get adapter by name
+   */
+  getAdapter(name: string): IAdapter | undefined {
+    return this.adapters.get(name);
+  }
+
+  /**
+   * Auto-detect which tool is being used
+   *
+   * Detection priority (based on market share and probability):
+   * 1. Claude Code (if .claude/ exists or claude CLI found) - NATIVE, no adapter needed
+   * 2. Cursor (if cursor CLI or .cursor/ or .cursorrules exists)
+   * 3. Gemini CLI (if gemini CLI found)
+   * 4. Codex (if codex CLI found)
+   * 5. Copilot (if .github/copilot/ exists)
+   * 6. Generic (fallback - always returns true)
+   *
+   * @returns Promise<string> Detected tool name (not adapter - Claude has no adapter!)
+   */
+  async detectTool(): Promise<string> {
+    console.log('🔍 Detecting AI coding tool...\n');
+
+    // Check for Claude first (native, no adapter)
+    if (await this.commandExists('claude') || await this.fileExists('.claude')) {
+      console.log(`✅ Detected: Claude Code (native - full automation)`);
+      return 'claude';
+    }
+
+    // Check other tools (need adapters)
+    const detectionOrder = ['cursor', 'gemini', 'codex', 'copilot', 'generic'];
+
+    for (const adapterName of detectionOrder) {
+      const adapter = this.adapters.get(adapterName);
+      if (!adapter) continue;
+
+      const detected = await adapter.detect();
+      if (detected) {
+        console.log(`✅ Detected: ${adapter.name} (${adapter.automationLevel} automation)`);
+        return adapterName;
+      }
+    }
+
+    // Fallback to generic (should never reach here since generic always returns true)
+    console.log('ℹ️  Using generic adapter (manual workflow)');
+    return 'generic';
+  }
+
+  /**
+   * Helper: Check if a command exists in PATH
+   */
+  private async commandExists(command: string): Promise<boolean> {
+    try {
+      execSync(`which ${command}`, { stdio: 'ignore' });
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Helper: Check if a file exists
+   */
+  private async fileExists(filePath: string): Promise<boolean> {
+    try {
+      await fs.access(filePath);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Check requirements for a specific adapter
+   */
+  async checkRequirements(adapterName: string): Promise<void> {
+    const adapter = this.adapters.get(adapterName);
+    if (!adapter) {
+      throw new Error(`Adapter not found: ${adapterName}`);
+    }
+
+    const result = await adapter.checkRequirements();
+
+    if (!result.met) {
+      console.error('\n❌ Requirements not met:\n');
+      result.missing.forEach(req => console.error(`  - ${req}`));
+      throw new Error('System requirements not met');
+    }
+
+    if (result.warnings.length > 0) {
+      console.warn('\n⚠️  Warnings:\n');
+      result.warnings.forEach(warning => console.warn(`  - ${warning}`));
+    }
+  }
+
+  /**
+   * List all available adapters with details
+   */
+  async listAdapters(): Promise<void> {
+    const registry = await this.loadRegistry();
+
+    console.log('\n📋 SpecWeave Tool Support:\n');
+    console.log('━'.repeat(70));
+    console.log('');
+
+    // Show Claude first (baseline, not an adapter)
+    const claudeInfo = registry.adapters.find(a => a.name === 'claude');
+    if (claudeInfo) {
+      console.log(`🚀 CLAUDE CODE (Baseline - No Adapter Needed)`);
+      console.log(`   ${claudeInfo.description}`);
+      console.log(`   Native: skills, agents, hooks, slash commands | Market: ${claudeInfo.market_share}`);
+      console.log('');
+    }
+
+    console.log('📦 Adapters (For Other Tools):\n');
+
+    // Show other adapters
+    for (const adapterInfo of registry.adapters) {
+      if (adapterInfo.name === 'claude') continue; // Skip Claude, already shown
+
+      const adapter = this.adapters.get(adapterInfo.name);
+      if (!adapter) continue;
+
+      console.log(`${this.getAutomationIcon(adapter.automationLevel)} ${adapter.name.toUpperCase()}`);
+      console.log(`   ${adapter.description}`);
+      console.log(`   Automation: ${adapter.automationLevel} | Market: ${adapterInfo.market_share}`);
+      console.log('');
+    }
+
+    console.log('━'.repeat(70));
+    console.log('\nTotal Market Coverage: 100%');
+    console.log('SpecWeave works with ANY AI coding tool!');
+    console.log('\n💡 Claude Code = Native experience (no adapter)');
+    console.log('   Other tools = Adapters approximate Claude\'s capabilities\n');
+  }
+
+  /**
+   * Get icon for automation level
+   */
+  private getAutomationIcon(level: string): string {
+    switch (level) {
+      case 'full': return '🚀';
+      case 'semi': return '⚡';
+      case 'basic': return '📝';
+      case 'manual': return '📖';
+      default: return '❓';
+    }
+  }
+
+  /**
+   * Get recommended adapter based on detection and user preference
+   */
+  async getRecommendedAdapter(explicitChoice?: string): Promise<IAdapter> {
+    // If user explicitly chose an adapter, use it
+    if (explicitChoice) {
+      const adapter = this.adapters.get(explicitChoice);
+      if (!adapter) {
+        throw new Error(`Invalid adapter: ${explicitChoice}. Use 'claude', 'cursor', 'copilot', or 'generic'`);
+      }
+      return adapter;
+    }
+
+    // Otherwise, auto-detect
+    const detectedName = await this.detectTool();
+    const adapter = this.adapters.get(detectedName);
+
+    if (!adapter) {
+      throw new Error(`Detected adapter not found: ${detectedName}`);
+    }
+
+    return adapter;
+  }
+}

package/src/adapters/agents-md-generator.ts

@@ -0,0 +1,162 @@
+/**
+ * AGENTS.md Generator
+ *
+ * Generates a universal AGENTS.md file for ALL AI coding tools EXCEPT Claude Code.
+ * Follows the agents.md standard: https://agents.md/
+ *
+ * IMPORTANT:
+ * - Claude Code does NOT read this file - it only reads CLAUDE.md
+ * - This file is for: Cursor, Gemini CLI, Codex, GitHub Copilot, and ANY other AI tool
+ *
+ * This ONE file replaces:
+ * - .cursorrules (Cursor)
+ * - .github/copilot/instructions.md (Copilot)
+ * - Any other tool-specific configuration files
+ */
+
+import { DocGenerator } from './doc-generator.js';
+import * as path from 'path';
+import fs from 'fs-extra';
+import { getDirname } from '../utils/esm-helpers.js';
+
+const __dirname = getDirname(import.meta.url);
+
+export interface AgentsMdOptions {
+  projectName: string;
+  projectPath: string;
+  templatePath?: string;
+}
+
+/**
+ * Generate universal AGENTS.md file
+ */
+export class AgentsMdGenerator {
+  private docGen: DocGenerator;
+
+  constructor(
+    skillsDir?: string,
+    agentsDir?: string,
+    commandsDir?: string
+  ) {
+    this.docGen = new DocGenerator(skillsDir, agentsDir, commandsDir);
+  }
+
+  /**
+   * Generate complete AGENTS.md content
+   */
+  async generate(options: AgentsMdOptions): Promise<string> {
+    // Read template
+    const templatePath = options.templatePath ||
+      path.join(__dirname, '../templates/AGENTS.md.template');
+
+    if (!await fs.pathExists(templatePath)) {
+      throw new Error(`AGENTS.md template not found at: ${templatePath}`);
+    }
+
+    let content = await fs.readFile(templatePath, 'utf-8');
+
+    // Extract agents and skills
+    const skills = await this.docGen.extractSkills();
+    const agents = await this.docGen.extractAgents();
+
+    // Replace placeholders
+    content = content.replace(/\{PROJECT_NAME\}/g, options.projectName);
+    content = content.replace('{AGENTS_SECTION}', this.generateAgentsSection(agents));
+    content = content.replace('{SKILLS_SECTION}', this.generateSkillsSection(skills));
+    content = content.replace('{TIMESTAMP}', new Date().toISOString().split('T')[0]);
+
+    return content;
+  }
+
+  /**
+   * Generate agents section as simple Markdown
+   */
+  private generateAgentsSection(agents: any[]): string {
+    let section = '';
+
+    for (const agent of agents) {
+      section += `### ${agent.role}\n`;
+      section += `**Purpose**: ${agent.description}\n`;
+      section += `**When to use**: ${this.getAgentActivation(agent.name)}\n`;
+      section += `**Location**: \`.claude/agents/${agent.name}/AGENT.md\`\n\n`;
+    }
+
+    return section;
+  }
+
+  /**
+   * Get agent activation guidance
+   */
+  private getAgentActivation(agentName: string): string {
+    const activations: Record<string, string> = {
+      'pm': 'Creating requirements, user stories, product specs (WHAT/WHY)',
+      'architect': 'System design, architecture decisions, technical plans (HOW)',
+      'devops': 'Infrastructure, deployment, CI/CD pipelines',
+      'qa-lead': 'Test strategy, test cases, quality assurance',
+      'security': 'Threat modeling, security review, vulnerability assessment',
+      'tech-lead': 'Code review, best practices, refactoring',
+      'frontend': 'UI components, React/Vue/Angular implementation',
+      'nodejs-backend': 'Node.js/Express/NestJS backend APIs',
+      'python-backend': 'FastAPI/Django backend APIs',
+      'nextjs': 'Next.js App Router applications',
+      'dotnet-backend': 'ASP.NET Core backend APIs',
+      'sre': 'Incident response, troubleshooting, runbooks',
+      'docs-writer': 'Technical documentation, API docs, guides',
+      'performance': 'Performance optimization, profiling, benchmarking'
+    };
+
+    return activations[agentName] || 'Specialized tasks requiring this expertise';
+  }
+
+  /**
+   * Generate skills section as simple Markdown
+   */
+  private generateSkillsSection(skills: any[]): string {
+    let section = '';
+
+    for (const skill of skills) {
+      section += `### ${skill.name}\n`;
+      section += `**Purpose**: ${skill.description}\n`;
+      section += `**When to use**: ${this.getSkillActivation(skill.name)}\n`;
+      section += `**Location**: \`.claude/skills/${skill.name}/SKILL.md\`\n\n`;
+    }
+
+    return section;
+  }
+
+  /**
+   * Get skill activation guidance
+   */
+  private getSkillActivation(skillName: string): string {
+    const activations: Record<string, string> = {
+      'specweave-detector': 'User asks about SpecWeave commands or workflows',
+      'increment-planner': 'Creating new feature increments (/inc command)',
+      'context-loader': 'Working on increments, need to load relevant context',
+      'skill-router': 'Ambiguous requests that need routing to specific skills',
+      'spec-driven-debugging': 'Bug investigation, test failures, unexpected behavior',
+      'spec-driven-brainstorming': 'Brainstorming ideas, refining concepts, design thinking',
+      'brownfield-analyzer': 'Analyzing existing projects for SpecWeave migration',
+      'brownfield-onboarder': 'Onboarding existing projects to SpecWeave',
+      'nodejs-backend': 'Node.js/Express/NestJS backend development',
+      'python-backend': 'Python/FastAPI/Django backend development',
+      'nextjs': 'Next.js App Router application development',
+      'frontend': 'React/Vue/Angular frontend development',
+      'dotnet-backend': 'ASP.NET Core backend development',
+      'e2e-playwright': 'End-to-end testing with Playwright',
+      'jira-sync': 'JIRA integration and synchronization',
+      'github-sync': 'GitHub issues/milestones synchronization',
+      'ado-sync': 'Azure DevOps synchronization',
+      'hetzner-provisioner': 'Hetzner Cloud infrastructure provisioning',
+      'cost-optimizer': 'Cloud cost optimization and platform comparison',
+      'figma-mcp-connector': 'Figma design integration via MCP',
+      'design-system-architect': 'Design system and Atomic Design methodology',
+      'figma-designer': 'Figma design creation and design tokens',
+      'figma-implementer': 'Converting Figma designs to code',
+      'figma-to-code': 'Figma to React/Angular code generation',
+      'role-orchestrator': 'Multi-agent orchestration for complex tasks',
+      'increment-quality-judge': 'AI-powered quality assessment of specs and plans'
+    };
+
+    return activations[skillName] || 'Specialized tasks';
+  }
+}

package/src/adapters/claude/README.md

@@ -63,9 +63,9 @@ This adapter represents the **gold standard** - all other adapters attempt to ap
 | Command | Purpose |
 |---------|---------|
 | `/create-increment` | Create new feature increment |
-| `/review-docs` | Review strategic documentation |
+| `/sync-docs` | Review strategic documentation |
 | `/sync-github` | Sync to GitHub issues |
-| `/create-project` | Bootstrap new project |
+| `specweave init` | Bootstrap new project |
 
 **Plus more commands** (see `.claude/commands/`)
 
@@ -107,7 +107,7 @@ npm run install:agents
 │   └── ...
 ├── commands/               # Slash commands
 │   ├── create-increment.md
-│   ├── review-docs.md
+│   ├── sync-docs.md
 │   └── ...
 └── hooks/                  # Auto-update mechanisms
     ├── post-task-completion.sh
@@ -135,10 +135,10 @@ npm run install:agents
 
 ### Example 2: Review Documentation
 
-**User**: `/review-docs`
+**User**: `/sync-docs`
 
 **What Happens** (Automatic):
-1. ✅ Slash command loads `.claude/commands/review-docs.md`
+1. ✅ Slash command loads `.claude/commands/sync-docs.md`
 2. ✅ Reviews strategic docs (.specweave/docs/internal/strategy/)
 3. ✅ Compares against actual implementation
 4. ✅ Identifies gaps (undocumented features, outdated docs, tech debt)
@@ -206,15 +206,7 @@ Agents have separate context windows to prevent pollution of main conversation.
 
 Hooks run automatically on events:
 
-```yaml
-# .specweave/config.yaml
-hooks:
-  post_task_completion:
-    enabled: true
-    actions:
-      - update_documentation
-      - update_claude_md
-```
+
 
 When task completes → hook fires → docs auto-update.
 

package/src/adapters/claude/adapter.ts

@@ -9,9 +9,9 @@
  */
 
 import * as path from 'path';
-import * as fs from 'fs-extra';
-import { AdapterBase } from '../adapter-base';
-import { AdapterOptions, AdapterFile } from '../adapter-interface';
+import fs from 'fs-extra';
+import { AdapterBase } from '../adapter-base.js';
+import { AdapterOptions, AdapterFile } from '../adapter-interface.js';
 
 export class ClaudeAdapter extends AdapterBase {
   name = 'claude';
@@ -131,7 +131,7 @@ WHAT THIS PROVIDES:
 
 - Skills (Auto-Activating): specweave-detector, skill-router, context-loader, increment-planner
 - Agents (Specialized Roles): PM, Architect, DevOps, QA, Security, and 14 more
-- Slash Commands: /create-increment, /review-docs, /sync-github, /create-project
+- Slash Commands: /specweave inc, /specweave do, /specweave validate, /specweave sync-github
 - Hooks (Auto-Update): post-task-completion, pre-implementation, docs-changed
 
 WHY CLAUDE CODE IS BEST: