devflow-kit 0.9.0 → 1.1.0

package/dist/utils/safe-delete-install.js

@@ -0,0 +1,191 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+const START_MARKER = '# >>> DevFlow safe-delete >>>';
+const END_MARKER = '# <<< DevFlow safe-delete <<<';
+/** Bump this when the safe-delete block changes. */
+export const SAFE_DELETE_BLOCK_VERSION = 2;
+/**
+ * Generate the safe-delete shell function block with markers.
+ * Returns null for unsupported shells.
+ */
+export function generateSafeDeleteBlock(shell, platform, trashCommand) {
+    if (shell === 'unknown')
+        return null;
+    if (shell === 'bash' || shell === 'zsh') {
+        const cmd = trashCommand ?? 'trash';
+        return [
+            START_MARKER,
+            `# v${SAFE_DELETE_BLOCK_VERSION}`,
+            `rm() {`,
+            `  local files=()`,
+            `  for arg in "$@"; do`,
+            `    [[ "$arg" =~ ^- ]] || files+=("$arg")`,
+            `  done`,
+            `  local existing=()`,
+            `  for f in "\${files[@]}"; do`,
+            `    [ -e "$f" ] || [ -L "$f" ] && existing+=("$f")`,
+            `  done`,
+            `  if (( \${#existing[@]} > 0 )); then`,
+            `    ${cmd} "\${existing[@]}"`,
+            `  fi`,
+            `}`,
+            `command() {`,
+            `  if [[ "$1" == "rm" ]]; then`,
+            `    shift; rm "$@"`,
+            `  else`,
+            `    builtin command "$@"`,
+            `  fi`,
+            `}`,
+            END_MARKER,
+        ].join('\n');
+    }
+    if (shell === 'fish') {
+        const cmd = trashCommand ?? 'trash';
+        return [
+            START_MARKER,
+            `# v${SAFE_DELETE_BLOCK_VERSION}`,
+            `function rm --description "Safe delete via trash"`,
+            `  set -l files`,
+            `  for arg in $argv`,
+            `    if not string match -q -- '-*' $arg`,
+            `      set files $files $arg`,
+            `    end`,
+            `  end`,
+            `  set -l existing`,
+            `  for f in $files`,
+            `    if test -e $f; or test -L $f`,
+            `      set existing $existing $f`,
+            `    end`,
+            `  end`,
+            `  if test (count $existing) -gt 0`,
+            `    ${cmd} $existing`,
+            `  end`,
+            `end`,
+            END_MARKER,
+        ].join('\n');
+    }
+    if (shell === 'powershell') {
+        if (platform === 'win32') {
+            return [
+                START_MARKER,
+                `# v${SAFE_DELETE_BLOCK_VERSION}`,
+                `if (Get-Alias rm -ErrorAction SilentlyContinue) {`,
+                `  Remove-Alias rm -Force -Scope Global`,
+                `}`,
+                `function rm {`,
+                `  $files = $args | Where-Object { $_ -notlike '-*' }`,
+                `  if ($files) {`,
+                `    Add-Type -AssemblyName Microsoft.VisualBasic`,
+                `    foreach ($f in $files) {`,
+                `      $p = Resolve-Path $f -ErrorAction SilentlyContinue`,
+                `      if ($p) {`,
+                `        if (Test-Path $p -PathType Container) {`,
+                `          [Microsoft.VisualBasic.FileIO.FileSystem]::DeleteDirectory(`,
+                `            $p, 'OnlyErrorDialogs', 'SendToRecycleBin')`,
+                `        } else {`,
+                `          [Microsoft.VisualBasic.FileIO.FileSystem]::DeleteFile(`,
+                `            $p, 'OnlyErrorDialogs', 'SendToRecycleBin')`,
+                `        }`,
+                `      }`,
+                `    }`,
+                `  }`,
+                `}`,
+                END_MARKER,
+            ].join('\n');
+        }
+        // macOS/Linux PowerShell
+        const cmd = trashCommand ?? 'trash';
+        return [
+            START_MARKER,
+            `# v${SAFE_DELETE_BLOCK_VERSION}`,
+            `if (Get-Alias rm -ErrorAction SilentlyContinue) {`,
+            `  Remove-Alias rm -Force -Scope Global`,
+            `}`,
+            `function rm {`,
+            `  $files = $args | Where-Object { $_ -notlike '-*' }`,
+            `  $existing = $files | Where-Object { Test-Path $_ }`,
+            `  if ($existing) { & ${cmd} @existing }`,
+            `}`,
+            END_MARKER,
+        ].join('\n');
+    }
+    return null;
+}
+/**
+ * Check if the safe-delete block is already installed in a profile file.
+ */
+export async function isAlreadyInstalled(profilePath) {
+    try {
+        const content = await fs.readFile(profilePath, 'utf-8');
+        return content.includes(START_MARKER) && content.includes(END_MARKER);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Append the safe-delete block to a profile file.
+ * Creates parent directories and the file if they don't exist.
+ */
+export async function installToProfile(profilePath, block) {
+    await fs.mkdir(path.dirname(profilePath), { recursive: true });
+    let existing = '';
+    try {
+        existing = await fs.readFile(profilePath, 'utf-8');
+    }
+    catch {
+        // File doesn't exist yet — will be created
+    }
+    const separator = existing.length > 0 && !existing.endsWith('\n') ? '\n\n' : '\n';
+    const content = existing.length > 0 ? existing + separator + block + '\n' : block + '\n';
+    await fs.writeFile(profilePath, content, 'utf-8');
+}
+/**
+ * Extract the installed safe-delete block version from a profile file.
+ * Returns 0 (not installed), 1 (legacy block without version stamp), or N (versioned block).
+ */
+export async function getInstalledVersion(profilePath) {
+    try {
+        const content = await fs.readFile(profilePath, 'utf-8');
+        const startIdx = content.indexOf(START_MARKER);
+        if (startIdx === -1)
+            return 0;
+        const afterMarker = content.slice(startIdx + START_MARKER.length);
+        const match = afterMarker.match(/^\n# v(\d+)/);
+        return match ? parseInt(match[1], 10) : 1;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Remove the safe-delete block from a profile file.
+ * Returns true if the block was found and removed, false otherwise.
+ * For fish function files, deletes the file if it becomes empty.
+ */
+export async function removeFromProfile(profilePath) {
+    let content;
+    try {
+        content = await fs.readFile(profilePath, 'utf-8');
+    }
+    catch {
+        return false;
+    }
+    const startIdx = content.indexOf(START_MARKER);
+    const endIdx = content.indexOf(END_MARKER);
+    if (startIdx === -1 || endIdx === -1)
+        return false;
+    const before = content.slice(0, startIdx);
+    const after = content.slice(endIdx + END_MARKER.length);
+    // Clean up surrounding whitespace
+    const cleaned = (before.trimEnd() + after.trimStart()).trim();
+    if (cleaned.length === 0) {
+        // File is empty after removal — delete it (fish function files)
+        await fs.unlink(profilePath);
+    }
+    else {
+        await fs.writeFile(profilePath, cleaned + '\n', 'utf-8');
+    }
+    return true;
+}
+//# sourceMappingURL=safe-delete-install.js.map

package/dist/utils/safe-delete.d.ts

@@ -0,0 +1,12 @@
+export type Platform = 'macos' | 'linux' | 'windows';
+export type Shell = 'zsh' | 'bash' | 'fish' | 'powershell' | 'unknown';
+export interface SafeDeleteInfo {
+    command: string | null;
+    installHint: string | null;
+}
+export declare function detectPlatform(): Platform;
+export declare function detectShell(): Shell;
+export declare function getProfilePath(shell: Shell): string | null;
+export declare function getSafeDeleteInfo(platform: Platform): SafeDeleteInfo;
+export declare function hasSafeDelete(platform: Platform): boolean;
+//# sourceMappingURL=safe-delete.d.ts.map

package/dist/utils/safe-delete.js

@@ -0,0 +1,83 @@
+import { execSync } from 'child_process';
+import { homedir } from 'os';
+import * as path from 'path';
+export function detectPlatform() {
+    switch (process.platform) {
+        case 'darwin': return 'macos';
+        case 'win32': return 'windows';
+        default: return 'linux';
+    }
+}
+export function detectShell() {
+    // PowerShell detection via PSModulePath (set in all PowerShell sessions)
+    if (process.env.PSModulePath) {
+        return 'powershell';
+    }
+    const shellPath = process.env.SHELL;
+    if (!shellPath)
+        return 'unknown';
+    const shellName = path.basename(shellPath);
+    switch (shellName) {
+        case 'zsh': return 'zsh';
+        case 'bash': return 'bash';
+        case 'fish': return 'fish';
+        default: return 'unknown';
+    }
+}
+export function getProfilePath(shell) {
+    const home = process.env.HOME || homedir();
+    switch (shell) {
+        case 'zsh':
+            return path.join(home, '.zshrc');
+        case 'bash':
+            return path.join(home, '.bashrc');
+        case 'fish':
+            return path.join(home, '.config', 'fish', 'functions', 'rm.fish');
+        case 'powershell': {
+            // PowerShell profile path varies by platform
+            if (process.platform === 'win32') {
+                const docs = process.env.USERPROFILE
+                    ? path.join(process.env.USERPROFILE, 'Documents')
+                    : path.join(home, 'Documents');
+                return path.join(docs, 'PowerShell', 'Microsoft.PowerShell_profile.ps1');
+            }
+            return path.join(home, '.config', 'powershell', 'Microsoft.PowerShell_profile.ps1');
+        }
+        case 'unknown':
+            return null;
+    }
+}
+export function getSafeDeleteInfo(platform) {
+    switch (platform) {
+        case 'macos':
+            return {
+                command: 'trash',
+                installHint: 'brew install trash-cli',
+            };
+        case 'linux':
+            return {
+                command: 'trash-put',
+                installHint: 'sudo apt install trash-cli  # or: npm install -g trash-cli',
+            };
+        case 'windows':
+            return {
+                command: null,
+                installHint: null,
+            };
+    }
+}
+export function hasSafeDelete(platform) {
+    if (platform === 'windows')
+        return true; // Windows has recycle bin via .NET
+    const info = getSafeDeleteInfo(platform);
+    if (!info.command)
+        return false;
+    try {
+        execSync(`which ${info.command}`, { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=safe-delete.js.map

package/package.json

@@ -1,25 +1,31 @@
 {
   "name": "devflow-kit",
-  "version": "0.9.0",
+  "version": "1.1.0",
   "description": "Agentic Development Toolkit for Claude Code - Enhance AI-assisted development with intelligent commands and workflows",
-  "main": "dist/index.js",
   "type": "module",
   "bin": {
     "devflow": "dist/cli.js"
   },
   "files": [
     "dist/",
-    "src/claude/",
+    "!dist/**/*.map",
+    "plugins/",
+    "shared/",
+    "scripts/hooks/",
+    "src/templates/",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "npm run build:cli && npm run build:plugins",
+    "build:cli": "tsc",
+    "build:plugins": "npx tsx scripts/build-plugins.ts",
     "dev": "tsc --watch",
     "cli": "node dist/cli.js",
     "prepublishOnly": "npm run build",
-    "test": "echo \"No tests yet\" && exit 0"
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "keywords": [
     "claude",
@@ -40,15 +46,19 @@
   "bugs": {
     "url": "https://github.com/dean0x/devflow/issues"
   },
-  "homepage": "https://github.com/dean0x/devflow#readme",
+  "homepage": "https://dean0x.github.io/x/devflow/",
   "engines": {
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "commander": "^12.0.0"
+    "@clack/prompts": "^0.9.1",
+    "commander": "^12.0.0",
+    "picocolors": "^1.1.1"
   },
   "devDependencies": {
     "@types/node": "^20.11.0",
-    "typescript": "^5.3.3"
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3",
+    "vitest": "^4.0.18"
   }
 }

package/plugins/devflow-ambient/.claude-plugin/plugin.json

@@ -0,0 +1,7 @@
+{
+  "name": "devflow-ambient",
+  "description": "Ambient mode — auto-loads relevant skills for every prompt",
+  "version": "1.1.0",
+  "agents": [],
+  "skills": ["ambient-router"]
+}

package/plugins/devflow-ambient/README.md

@@ -0,0 +1,49 @@
+# devflow-ambient
+
+Ambient mode — auto-loads relevant skills based on each prompt, no explicit commands needed.
+
+## Command
+
+### `/ambient`
+
+Classify user intent and apply proportional skill enforcement to any prompt.
+
+```bash
+/ambient add a login form          # BUILD/STANDARD — loads TDD + implementation-patterns
+/ambient fix the auth error        # DEBUG/STANDARD — loads test-patterns + core-patterns
+/ambient where is the config?      # EXPLORE/QUICK — responds normally, zero overhead
+/ambient refactor the auth system  # BUILD/ESCALATE — suggests /implement
+```
+
+## Always-On Mode
+
+Enable ambient classification on every prompt without typing `/ambient`:
+
+```bash
+devflow ambient --enable    # Register UserPromptSubmit hook
+devflow ambient --disable   # Remove hook
+devflow ambient --status    # Check if enabled
+```
+
+When enabled, a `UserPromptSubmit` hook injects a classification preamble before every prompt. Slash commands (`/implement`, `/code-review`, etc.) and short confirmations ("yes", "ok") are skipped automatically.
+
+## How It Works
+
+1. **Classify intent** — BUILD, DEBUG, REVIEW, PLAN, EXPLORE, or CHAT
+2. **Classify depth** — QUICK (zero overhead), STANDARD (2-3 skills), or ESCALATE (workflow nudge)
+3. **Apply proportionally**:
+   - QUICK: respond normally
+   - STANDARD: load relevant skills, enforce TDD for BUILD
+   - ESCALATE: respond + recommend full workflow command
+
+## Depth Tiers
+
+| Depth | When | Overhead |
+|-------|------|----------|
+| QUICK | Chat, simple exploration, git/devops ops, single-word confirmations | ~0 tokens |
+| STANDARD | BUILD/DEBUG/REVIEW/PLAN, 1-5 file scope | ~500-1000 tokens (skill reads) |
+| ESCALATE | Multi-file, architectural, system-wide scope | ~0 extra tokens (nudge only) |
+
+## Skills
+
+- `ambient-router` — Intent + depth classification, skill selection matrix

package/plugins/devflow-ambient/commands/ambient.md

@@ -0,0 +1,110 @@
+---
+description: Ambient mode — classify intent and auto-load relevant skills for any prompt
+---
+
+# Ambient Command
+
+Classify user intent and auto-load relevant skills. No agents spawned — enhances the main session only.
+
+## Usage
+
+```
+/ambient <prompt>           Classify and respond with skill enforcement
+/ambient                    Show usage
+```
+
+## Phases
+
+### Phase 1: Load Router
+
+Read the `ambient-router` skill:
+- `~/.claude/skills/ambient-router/SKILL.md`
+
+### Phase 2: Classify
+
+Apply the ambient-router classification to `$ARGUMENTS`:
+
+1. **Intent:** BUILD | DEBUG | REVIEW | PLAN | EXPLORE | CHAT
+2. **Depth:** QUICK | STANDARD | ESCALATE
+
+If no arguments provided, output:
+
+```
+## Ambient Mode
+
+Classify intent and auto-load relevant skills.
+
+Usage: /ambient <your prompt>
+
+Examples:
+  /ambient add a login form          → BUILD/STANDARD (loads TDD + implementation-patterns)
+  /ambient fix the auth error        → DEBUG/STANDARD (loads test-patterns + core-patterns)
+  /ambient where is the config?      → EXPLORE/QUICK (responds normally)
+  /ambient refactor the auth system  → BUILD/ESCALATE (suggests /implement)
+
+Always-on: devflow ambient --enable
+```
+
+Then stop.
+
+### Phase 3: State Classification
+
+- **QUICK:** Skip this phase entirely. Respond directly in Phase 4.
+- **STANDARD:** Output one line: `Ambient: {INTENT}/{DEPTH}. Loading: {skill1}, {skill2}.`
+- **ESCALATE:** Skip — recommendation happens in Phase 4.
+
+### Phase 4: Apply
+
+**QUICK:**
+Respond to the user's prompt normally. Zero skill loading. Zero overhead.
+
+**STANDARD:**
+Read the selected skills based on the ambient-router's skill selection matrix:
+
+| Intent | Primary Skills | Secondary (conditional) |
+|--------|---------------|------------------------|
+| BUILD | test-driven-development, implementation-patterns | typescript (.ts), react (.tsx), frontend-design (CSS/UI), input-validation (forms/API), security-patterns (auth/crypto) |
+| DEBUG | test-patterns, core-patterns | git-safety (if git ops) |
+| REVIEW | self-review, core-patterns | test-patterns |
+| PLAN | implementation-patterns | core-patterns |
+
+Read up to 3 skills from `~/.claude/skills/{name}/SKILL.md`. Apply their patterns and constraints when responding to the user's prompt.
+
+For BUILD intent: enforce RED-GREEN-REFACTOR from test-driven-development. Write failing tests before production code.
+
+**ESCALATE:**
+Respond to the user's prompt with your best effort, then append:
+
+> This task spans multiple files/systems. Consider `/implement` for full lifecycle management (exploration → planning → implementation → review).
+
+## Architecture
+
+```
+/ambient <prompt> (main session, no agents)
+│
+├─ Phase 1: Load ambient-router skill
+├─ Phase 2: Classify intent + depth
+├─ Phase 3: State classification (STANDARD only)
+└─ Phase 4: Apply
+   ├─ QUICK → respond directly
+   ├─ STANDARD → load 2-3 skills, apply patterns, respond
+   └─ ESCALATE → respond + workflow nudge
+```
+
+## Edge Cases
+
+| Case | Handling |
+|------|----------|
+| No arguments | Show usage and stop |
+| Single word ("help") | Classify — likely CHAT/QUICK |
+| Prompt references `/implement` etc. | Classify as normal — user chose /ambient intentionally |
+| Mixed intent ("fix and add test") | Use higher-overhead intent (BUILD > DEBUG) |
+| User says "no enforcement" | Respect immediately — treat as QUICK |
+
+## Principles
+
+1. **No agents** — Ambient enhances the main session, never spawns subagents
+2. **Proportional** — QUICK gets zero overhead, STANDARD gets 2-3 skills, ESCALATE gets a nudge
+3. **Transparent** — State classification for STANDARD/ESCALATE, silent for QUICK
+4. **Respectful** — Never over-classify; when in doubt, go one tier lower
+5. **TDD for BUILD** — STANDARD depth BUILD tasks enforce test-first workflow

package/plugins/devflow-ambient/skills/ambient-router/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: ambient-router
+description: >-
+  Classify user intent and response depth for ambient mode. Auto-loads relevant
+  skills without explicit command invocation. Used by /ambient command and
+  always-on UserPromptSubmit hook.
+user-invocable: false
+allowed-tools: Read, Grep, Glob
+---
+
+# Ambient Router
+
+Classify user intent and auto-load relevant skills. Zero overhead for simple requests, skill injection for substantive work, workflow nudges for complex tasks.
+
+## Iron Law
+
+> **PROPORTIONAL RESPONSE**
+>
+> Match effort to intent. Never apply heavyweight processes to lightweight requests.
+> A chat question gets zero overhead. A 3-file feature gets 2-3 skills. A system
+> refactor gets a nudge toward `/implement`. Misclassification in either direction
+> is a failure.
+
+---
+
+## Step 1: Classify Intent
+
+Determine what the user is trying to do from their prompt.
+
+| Intent | Signal Words / Patterns | Examples |
+|--------|------------------------|---------|
+| **BUILD** | "add", "create", "implement", "build", "write", "make" | "add a login form", "create an API endpoint" |
+| **DEBUG** | "fix", "bug", "broken", "failing", "error", "why does" | "fix the auth error", "why is this test failing" |
+| **REVIEW** | "check", "look at", "review", "is this ok", "any issues" | "check this function", "any issues with this?" |
+| **PLAN** | "how should", "design", "architecture", "approach", "strategy" | "how should I structure auth?", "what's the approach for caching?" |
+| **EXPLORE** | "what is", "where is", "find", "show me", "explain", "how does" | "where is the config?", "explain this function" |
+| **CHAT** | greetings, meta-questions, confirmations, short responses | "thanks", "yes", "what can you do?" |
+
+**Ambiguous prompts:** Default to the lowest-overhead classification. "Update the README" → BUILD/STANDARD. Git operations like "commit this" → QUICK.
+
+## Step 2: Classify Depth
+
+Determine how much enforcement the prompt warrants.
+
+| Depth | Criteria | Action |
+|-------|----------|--------|
+| **QUICK** | CHAT intent. EXPLORE with no analytical depth ("where is X?"). Git/devops operations (commit, push, merge, branch, pr, deploy, reinstall). Single-word continuations. | Respond normally. Zero overhead. Do not state classification. |
+| **STANDARD** | BUILD/DEBUG/REVIEW/PLAN intent (any word count). EXPLORE with analytical depth ("analyze our X", "discuss how Y works"). | Read and apply 2-3 relevant skills from the selection matrix below. State classification briefly. |
+| **ESCALATE** | Multi-file architectural change, system-wide scope, > 5 files. Detailed implementation plan (100+ words with plan structure). | Respond at best effort + recommend: "This looks like it would benefit from `/implement` for full lifecycle management." |
+
+## Step 3: Select Skills (STANDARD depth only)
+
+Based on classified intent, read the following skills to inform your response.
+
+| Intent | Primary Skills | Secondary (if file type matches) |
+|--------|---------------|----------------------------------|
+| **BUILD** | test-driven-development, implementation-patterns | typescript (.ts), react (.tsx/.jsx), frontend-design (CSS/UI), input-validation (forms/API), security-patterns (auth/crypto) |
+| **DEBUG** | test-patterns, core-patterns | git-safety (if git operations involved) |
+| **REVIEW** | self-review, core-patterns | test-patterns |
+| **PLAN** | implementation-patterns | core-patterns |
+
+**Excluded from ambient** (review-command-only): review-methodology, complexity-patterns, consistency-patterns, database-patterns, dependencies-patterns, documentation-patterns, regression-patterns, architecture-patterns, accessibility.
+
+See `references/skill-catalog.md` for the full skill-to-intent mapping with file pattern triggers.
+
+## Step 4: Apply
+
+- **QUICK:** Respond directly. No preamble, no classification statement.
+- **STANDARD:** State classification briefly: `Ambient: BUILD/STANDARD. Loading: test-driven-development, implementation-patterns.` Then read the selected skills and apply their patterns to your response. For BUILD intent, enforce RED-GREEN-REFACTOR from test-driven-development.
+- **ESCALATE:** Respond with your best effort, then append: `> This task spans multiple files/systems. Consider \`/implement\` for full lifecycle (exploration → planning → implementation → review).`
+
+---
+
+## Transparency Rules
+
+1. **QUICK → silent.** No classification output.
+2. **STANDARD → brief statement.** One line: intent, depth, skills loaded.
+3. **ESCALATE → recommendation.** Best-effort response + workflow nudge.
+4. **Never lie about classification.** If uncertain, say so.
+5. **Never over-classify.** When in doubt, go one tier lower.
+
+## Edge Cases
+
+| Case | Handling |
+|------|----------|
+| Mixed intent ("fix this bug and add a test") | Use the higher-overhead intent (BUILD > DEBUG) |
+| Continuation of previous conversation | Inherit previous classification unless prompt clearly shifts |
+| User explicitly requests no enforcement | Respect immediately — classify as QUICK |
+| Prompt references specific DevFlow command | Skip ambient — the command has its own orchestration |

package/plugins/devflow-ambient/skills/ambient-router/references/skill-catalog.md

@@ -0,0 +1,64 @@
+# Ambient Router — Skill Catalog
+
+Full mapping of DevFlow skills to ambient intents and file-type triggers. The ambient-router SKILL.md references this for detailed selection logic.
+
+## Skills Available for Ambient Loading
+
+These skills may be loaded during STANDARD-depth ambient routing.
+
+### BUILD Intent
+
+| Skill | When to Load | File Patterns |
+|-------|-------------|---------------|
+| test-driven-development | Always for BUILD | `*.ts`, `*.tsx`, `*.js`, `*.jsx`, `*.py` |
+| implementation-patterns | Always for BUILD | Any code file |
+| typescript | TypeScript files in scope | `*.ts`, `*.tsx` |
+| react | React components in scope | `*.tsx`, `*.jsx` |
+| frontend-design | UI/styling work | `*.css`, `*.scss`, `*.tsx` with styling keywords |
+| input-validation | Forms, APIs, user input | Files with form/input/validation keywords |
+| security-patterns | Auth, crypto, secrets | Files with auth/token/crypto/password keywords |
+
+### DEBUG Intent
+
+| Skill | When to Load | File Patterns |
+|-------|-------------|---------------|
+| test-patterns | Always for DEBUG | Any test-related context |
+| core-patterns | Always for DEBUG | Any code file |
+| git-safety | Git operations involved | User mentions git, rebase, merge, etc. |
+
+### REVIEW Intent
+
+| Skill | When to Load | File Patterns |
+|-------|-------------|---------------|
+| self-review | Always for REVIEW | Any code file |
+| core-patterns | Always for REVIEW | Any code file |
+| test-patterns | Test files in scope | `*.test.*`, `*.spec.*` |
+
+### PLAN Intent
+
+| Skill | When to Load | File Patterns |
+|-------|-------------|---------------|
+| implementation-patterns | Always for PLAN | Any planning context |
+| core-patterns | Architectural planning | System design discussions |
+
+## Skills Excluded from Ambient
+
+These skills are loaded only by explicit DevFlow commands (primarily `/code-review`):
+
+- review-methodology — Full review process (6-step, 3-category classification)
+- complexity-patterns — Cyclomatic complexity, deep nesting analysis
+- consistency-patterns — Naming convention, pattern deviation detection
+- database-patterns — Index analysis, query optimization, migration safety
+- dependencies-patterns — CVE detection, license audit, outdated packages
+- documentation-patterns — Doc drift, stale comments, missing API docs
+- regression-patterns — Lost functionality, broken exports, behavioral changes
+- architecture-patterns — SOLID analysis, coupling detection, layering issues
+- accessibility — WCAG compliance, ARIA roles, keyboard navigation
+- performance-patterns — N+1 queries, memory leaks, caching opportunities
+
+## Selection Limits
+
+- **Maximum 3 skills** per ambient response (primary + up to 2 secondary)
+- **Primary skills** are always loaded for the classified intent
+- **Secondary skills** are loaded only when file patterns match conversation context
+- If more than 3 skills seem relevant, this is an ESCALATE signal

package/plugins/devflow-audit-claude/.claude-plugin/plugin.json

@@ -0,0 +1,7 @@
+{
+  "name": "devflow-audit-claude",
+  "description": "Audit CLAUDE.md files against Anthropic best practices",
+  "version": "1.1.0",
+  "agents": [],
+  "skills": []
+}