devflow-kit 1.0.0 → 1.2.0

package/dist/commands/memory.js

@@ -0,0 +1,175 @@
+import { Command } from 'commander';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import * as p from '@clack/prompts';
+import color from 'picocolors';
+import { getClaudeDirectory, getDevFlowDirectory } from '../utils/paths.js';
+import { createMemoryDir, migrateMemoryFiles } from '../utils/post-install.js';
+/**
+ * Map of hook event type → filename marker for the 3 memory hooks.
+ */
+const MEMORY_HOOK_CONFIG = {
+    Stop: 'stop-update-memory.sh',
+    SessionStart: 'session-start-memory.sh',
+    PreCompact: 'pre-compact-memory.sh',
+};
+/**
+ * Add all 3 memory hooks (Stop, SessionStart, PreCompact) to settings JSON.
+ * Idempotent — skips hooks that already exist. Returns unchanged JSON if all 3 present.
+ */
+export function addMemoryHooks(settingsJson, devflowDir) {
+    const settings = JSON.parse(settingsJson);
+    if (hasMemoryHooks(settingsJson)) {
+        return settingsJson;
+    }
+    if (!settings.hooks) {
+        settings.hooks = {};
+    }
+    let changed = false;
+    for (const [hookType, marker] of Object.entries(MEMORY_HOOK_CONFIG)) {
+        const existing = settings.hooks[hookType] ?? [];
+        const alreadyPresent = existing.some((matcher) => matcher.hooks.some((h) => h.command.includes(marker)));
+        if (!alreadyPresent) {
+            const hookCommand = path.join(devflowDir, 'scripts', 'hooks', marker);
+            const newEntry = {
+                hooks: [
+                    {
+                        type: 'command',
+                        command: hookCommand,
+                        timeout: 10,
+                    },
+                ],
+            };
+            if (!settings.hooks[hookType]) {
+                settings.hooks[hookType] = [];
+            }
+            settings.hooks[hookType].push(newEntry);
+            changed = true;
+        }
+    }
+    if (!changed) {
+        return settingsJson;
+    }
+    return JSON.stringify(settings, null, 2) + '\n';
+}
+/**
+ * Remove all memory hooks (Stop, SessionStart, PreCompact) from settings JSON.
+ * Idempotent — returns unchanged JSON if no memory hooks present.
+ * Preserves non-memory hooks. Cleans empty arrays/objects.
+ */
+export function removeMemoryHooks(settingsJson) {
+    const settings = JSON.parse(settingsJson);
+    if (!settings.hooks) {
+        return settingsJson;
+    }
+    let changed = false;
+    for (const [hookType, marker] of Object.entries(MEMORY_HOOK_CONFIG)) {
+        if (!settings.hooks[hookType]) {
+            continue;
+        }
+        const before = settings.hooks[hookType].length;
+        settings.hooks[hookType] = settings.hooks[hookType].filter((matcher) => !matcher.hooks.some((h) => h.command.includes(marker)));
+        if (settings.hooks[hookType].length !== before) {
+            changed = true;
+        }
+        if (settings.hooks[hookType].length === 0) {
+            delete settings.hooks[hookType];
+        }
+    }
+    if (settings.hooks && Object.keys(settings.hooks).length === 0) {
+        delete settings.hooks;
+    }
+    if (!changed) {
+        return settingsJson;
+    }
+    return JSON.stringify(settings, null, 2) + '\n';
+}
+/**
+ * Check if ALL 3 memory hooks are registered in settings JSON.
+ */
+export function hasMemoryHooks(settingsJson) {
+    return countMemoryHooks(settingsJson) === 3;
+}
+/**
+ * Count how many of the 3 memory hooks are present (0-3).
+ */
+export function countMemoryHooks(settingsJson) {
+    const settings = JSON.parse(settingsJson);
+    if (!settings.hooks) {
+        return 0;
+    }
+    let count = 0;
+    for (const [hookType, marker] of Object.entries(MEMORY_HOOK_CONFIG)) {
+        const matchers = settings.hooks[hookType] ?? [];
+        if (matchers.some((matcher) => matcher.hooks.some((h) => h.command.includes(marker)))) {
+            count++;
+        }
+    }
+    return count;
+}
+export const memoryCommand = new Command('memory')
+    .description('Enable or disable working memory (session context preservation)')
+    .option('--enable', 'Add Stop/SessionStart/PreCompact hooks')
+    .option('--disable', 'Remove memory hooks')
+    .option('--status', 'Show current state')
+    .action(async (options) => {
+    const hasFlag = options.enable || options.disable || options.status;
+    if (!hasFlag) {
+        p.intro(color.bgCyan(color.white(' Working Memory ')));
+        p.note(`${color.cyan('devflow memory --enable')}   Add memory hooks\n` +
+            `${color.cyan('devflow memory --disable')}  Remove memory hooks\n` +
+            `${color.cyan('devflow memory --status')}   Check current state`, 'Usage');
+        p.outro(color.dim('Memory hooks provide automatic session context preservation'));
+        return;
+    }
+    const claudeDir = getClaudeDirectory();
+    const settingsPath = path.join(claudeDir, 'settings.json');
+    let settingsContent;
+    try {
+        settingsContent = await fs.readFile(settingsPath, 'utf-8');
+    }
+    catch {
+        if (options.status) {
+            p.log.info('Working memory: disabled (no settings.json found)');
+            return;
+        }
+        // Create minimal settings.json
+        settingsContent = '{}';
+    }
+    if (options.status) {
+        const count = countMemoryHooks(settingsContent);
+        if (count === 3) {
+            p.log.info(`Working memory: ${color.green('enabled')} (3/3 hooks)`);
+        }
+        else if (count === 0) {
+            p.log.info(`Working memory: ${color.dim('disabled')}`);
+        }
+        else {
+            p.log.info(`Working memory: ${color.yellow(`partial (${count}/3 hooks)`)} — run --enable to fix`);
+        }
+        return;
+    }
+    const devflowDir = getDevFlowDirectory();
+    if (options.enable) {
+        const updated = addMemoryHooks(settingsContent, devflowDir);
+        if (updated === settingsContent) {
+            p.log.info('Working memory already enabled');
+            return;
+        }
+        await fs.writeFile(settingsPath, updated, 'utf-8');
+        await createMemoryDir(false);
+        await migrateMemoryFiles(true);
+        p.log.success('Working memory enabled — Stop/SessionStart/PreCompact hooks registered');
+        p.log.info(color.dim('Session context will be automatically preserved across conversations'));
+    }
+    if (options.disable) {
+        const updated = removeMemoryHooks(settingsContent);
+        if (updated === settingsContent) {
+            p.log.info('Working memory already disabled');
+            return;
+        }
+        await fs.writeFile(settingsPath, updated, 'utf-8');
+        p.log.success('Working memory disabled — hooks removed');
+    }
+});
+//# sourceMappingURL=memory.js.map

package/dist/commands/uninstall.js

@@ -9,6 +9,8 @@ import { getInstallationPaths, getClaudeDirectory, getManagedSettingsPath } from
 import { getGitRoot } from '../utils/git.js';
 import { isClaudeCliAvailable } from '../utils/cli.js';
 import { DEVFLOW_PLUGINS, getAllSkillNames, LEGACY_SKILL_NAMES } from '../plugins.js';
+import { removeAmbientHook } from './ambient.js';
+import { removeMemoryHooks } from './memory.js';
 import { detectShell, getProfilePath } from '../utils/safe-delete.js';
 import { isAlreadyInstalled, removeFromProfile } from '../utils/safe-delete-install.js';
 import { removeManagedSettings } from '../utils/post-install.js';
@@ -176,6 +178,21 @@ export const uninstallCommand = new Command('uninstall')
         if (!usedCli) {
             if (isSelectiveUninstall) {
                 await removeSelectedPlugins(claudeDir, selectedPlugins, verbose);
+                // Clean up ambient hook if ambient plugin is being removed
+                if (selectedPlugins.some(sp => sp.name === 'devflow-ambient')) {
+                    const settingsPath = path.join(claudeDir, 'settings.json');
+                    try {
+                        const settings = await fs.readFile(settingsPath, 'utf-8');
+                        const updated = removeAmbientHook(settings);
+                        if (updated !== settings) {
+                            await fs.writeFile(settingsPath, updated, 'utf-8');
+                            if (verbose) {
+                                p.log.success('Ambient mode hook removed from settings.json');
+                            }
+                        }
+                    }
+                    catch { /* settings.json may not exist */ }
+                }
             }
             else {
                 await removeAllDevFlow(claudeDir, devflowScriptsDir, verbose);
@@ -221,7 +238,39 @@ export const uninstallCommand = new Command('uninstall')
                 p.log.info('.docs/ preserved');
             }
         }
-        // 2. .claudeignore
+        // 2. .memory/ directory
+        const memoryDir = path.join(process.cwd(), '.memory');
+        let memoryExist = false;
+        try {
+            await fs.access(memoryDir);
+            memoryExist = true;
+        }
+        catch { /* .memory doesn't exist */ }
+        if (memoryExist) {
+            let shouldRemoveMemory = false;
+            if (options.keepDocs) {
+                shouldRemoveMemory = false;
+            }
+            else if (process.stdin.isTTY) {
+                const removeMemory = await p.confirm({
+                    message: '.memory/ directory found. Remove working memory files?',
+                    initialValue: false,
+                });
+                if (p.isCancel(removeMemory)) {
+                    p.cancel('Uninstall cancelled.');
+                    process.exit(0);
+                }
+                shouldRemoveMemory = removeMemory;
+            }
+            if (shouldRemoveMemory) {
+                await fs.rm(memoryDir, { recursive: true, force: true });
+                p.log.success('.memory/ removed');
+            }
+            else {
+                p.log.info('.memory/ preserved');
+            }
+        }
+        // 4. .claudeignore
         const claudeignorePath = gitRoot
             ? path.join(gitRoot, '.claudeignore')
             : path.join(process.cwd(), '.claudeignore');
@@ -249,12 +298,30 @@ export const uninstallCommand = new Command('uninstall')
                 p.log.info('.claudeignore preserved (non-interactive mode)');
             }
         }
-        // 3. settings.json (DevFlow hooks)
+        // 5. settings.json (DevFlow hooks)
         for (const scope of scopesToUninstall) {
             try {
                 const paths = await getInstallationPaths(scope);
                 const settingsPath = path.join(paths.claudeDir, 'settings.json');
-                const settingsContent = await fs.readFile(settingsPath, 'utf-8');
+                let settingsContent = await fs.readFile(settingsPath, 'utf-8');
+                // Always remove ambient hook on full uninstall (idempotent)
+                const withoutAmbient = removeAmbientHook(settingsContent);
+                if (withoutAmbient !== settingsContent) {
+                    await fs.writeFile(settingsPath, withoutAmbient, 'utf-8');
+                    settingsContent = withoutAmbient;
+                    if (verbose) {
+                        p.log.success(`Ambient mode hook removed from settings.json (${scope})`);
+                    }
+                }
+                // Always remove memory hooks on full uninstall (idempotent)
+                const withoutMemory = removeMemoryHooks(settingsContent);
+                if (withoutMemory !== settingsContent) {
+                    await fs.writeFile(settingsPath, withoutMemory, 'utf-8');
+                    settingsContent = withoutMemory;
+                    if (verbose) {
+                        p.log.success(`Memory hooks removed from settings.json (${scope})`);
+                    }
+                }
                 const settings = JSON.parse(settingsContent);
                 if (settings.hooks) {
                     if (process.stdin.isTTY) {
@@ -280,7 +347,7 @@ export const uninstallCommand = new Command('uninstall')
                 // settings.json doesn't exist or can't be parsed — skip
             }
         }
-        // 4. Managed settings (security deny list)
+        // 6. Managed settings (security deny list)
         let managedSettingsExist = false;
         try {
             const managedPath = getManagedSettingsPath();
@@ -309,7 +376,7 @@ export const uninstallCommand = new Command('uninstall')
                 p.log.info('Managed settings preserved (non-interactive mode)');
             }
         }
-        // 5. Safe-delete shell function
+        // 7. Safe-delete shell function
         const shell = detectShell();
         const profilePath = getProfilePath(shell);
         if (profilePath && await isAlreadyInstalled(profilePath)) {

package/dist/plugins.js

@@ -10,7 +10,7 @@ export const DEVFLOW_PLUGINS = [
         description: 'Auto-activating quality enforcement (foundation layer)',
         commands: [],
         agents: [],
-        skills: ['accessibility', 'core-patterns', 'docs-framework', 'frontend-design', 'git-safety', 'git-workflow', 'github-patterns', 'input-validation', 'react', 'test-patterns', 'typescript'],
+        skills: ['core-patterns', 'docs-framework', 'git-safety', 'git-workflow', 'github-patterns', 'input-validation', 'test-driven-development', 'test-patterns'],
     },
     {
         name: 'devflow-specify',
@@ -24,14 +24,14 @@ export const DEVFLOW_PLUGINS = [
         description: 'Complete task implementation workflow',
         commands: ['/implement'],
         agents: ['git', 'skimmer', 'synthesizer', 'coder', 'simplifier', 'scrutinizer', 'shepherd', 'validator'],
-        skills: ['accessibility', 'agent-teams', 'frontend-design', 'implementation-patterns', 'self-review'],
+        skills: ['agent-teams', 'implementation-patterns', 'self-review'],
     },
     {
         name: 'devflow-code-review',
         description: 'Comprehensive code review',
         commands: ['/code-review'],
         agents: ['git', 'reviewer', 'synthesizer'],
-        skills: ['accessibility', 'agent-teams', 'architecture-patterns', 'complexity-patterns', 'consistency-patterns', 'database-patterns', 'dependencies-patterns', 'documentation-patterns', 'frontend-design', 'performance-patterns', 'react', 'regression-patterns', 'review-methodology', 'security-patterns', 'test-patterns'],
+        skills: ['agent-teams', 'architecture-patterns', 'complexity-patterns', 'consistency-patterns', 'database-patterns', 'dependencies-patterns', 'documentation-patterns', 'performance-patterns', 'regression-patterns', 'review-methodology', 'security-patterns', 'test-patterns'],
     },
     {
         name: 'devflow-resolve',
@@ -54,6 +54,13 @@ export const DEVFLOW_PLUGINS = [
         agents: ['simplifier', 'scrutinizer', 'validator'],
         skills: ['self-review', 'core-patterns'],
     },
+    {
+        name: 'devflow-ambient',
+        description: 'Ambient mode — auto-loads relevant skills based on each prompt',
+        commands: ['/ambient'],
+        agents: [],
+        skills: ['ambient-router'],
+    },
     {
         name: 'devflow-audit-claude',
         description: 'Audit CLAUDE.md files against Anthropic best practices',
@@ -62,6 +69,70 @@ export const DEVFLOW_PLUGINS = [
         skills: [],
         optional: true,
     },
+    {
+        name: 'devflow-typescript',
+        description: 'TypeScript language patterns (type safety, generics, utility types)',
+        commands: [],
+        agents: [],
+        skills: ['typescript'],
+        optional: true,
+    },
+    {
+        name: 'devflow-react',
+        description: 'React framework patterns (hooks, state, composition, performance)',
+        commands: [],
+        agents: [],
+        skills: ['react'],
+        optional: true,
+    },
+    {
+        name: 'devflow-accessibility',
+        description: 'Web accessibility patterns (WCAG, ARIA, keyboard navigation)',
+        commands: [],
+        agents: [],
+        skills: ['accessibility'],
+        optional: true,
+    },
+    {
+        name: 'devflow-frontend-design',
+        description: 'Frontend design patterns (typography, color, spacing, motion)',
+        commands: [],
+        agents: [],
+        skills: ['frontend-design'],
+        optional: true,
+    },
+    {
+        name: 'devflow-go',
+        description: 'Go language patterns (error handling, interfaces, concurrency)',
+        commands: [],
+        agents: [],
+        skills: ['go'],
+        optional: true,
+    },
+    {
+        name: 'devflow-java',
+        description: 'Java language patterns (records, sealed classes, composition)',
+        commands: [],
+        agents: [],
+        skills: ['java'],
+        optional: true,
+    },
+    {
+        name: 'devflow-python',
+        description: 'Python language patterns (type hints, protocols, data modeling)',
+        commands: [],
+        agents: [],
+        skills: ['python'],
+        optional: true,
+    },
+    {
+        name: 'devflow-rust',
+        description: 'Rust language patterns (ownership, error handling, type system)',
+        commands: [],
+        agents: [],
+        skills: ['rust'],
+        optional: true,
+    },
 ];
 /**
  * Deprecated command names from old installations.

package/dist/utils/post-install.d.ts

@@ -65,4 +65,16 @@ export declare function updateGitignore(gitRoot: string, verbose: boolean): Prom
  * Create .docs/ directory structure for DevFlow artifacts.
  */
 export declare function createDocsStructure(verbose: boolean): Promise<void>;
+/**
+ * Create .memory/ directory for working memory files.
+ * Separate from .docs/ which is for reviews/releases.
+ */
+export declare function createMemoryDir(verbose: boolean, cwd?: string): Promise<void>;
+/**
+ * Migrate memory files from .docs/ to .memory/.
+ * One-time migration for existing users. Skips if destination exists (no clobber).
+ * Also cleans up ephemeral files from .docs/.
+ * Returns count of migrated files.
+ */
+export declare function migrateMemoryFiles(verbose: boolean, cwd?: string): Promise<number>;
 //# sourceMappingURL=post-install.d.ts.map

package/dist/utils/post-install.js

@@ -386,7 +386,7 @@ export async function installClaudeignore(gitRoot, rootDir, verbose) {
 export async function updateGitignore(gitRoot, verbose) {
     try {
         const gitignorePath = path.join(gitRoot, '.gitignore');
-        const entriesToAdd = ['.claude/', '.devflow/'];
+        const entriesToAdd = ['.claude/', '.devflow/', '.memory/', '.docs/'];
         let gitignoreContent = '';
         try {
             gitignoreContent = await fs.readFile(gitignorePath, 'utf-8');
@@ -424,4 +424,85 @@ export async function createDocsStructure(verbose) {
     }
     catch { /* may already exist */ }
 }
+/**
+ * Create .memory/ directory for working memory files.
+ * Separate from .docs/ which is for reviews/releases.
+ */
+export async function createMemoryDir(verbose, cwd) {
+    const memoryDir = path.join(cwd ?? process.cwd(), '.memory');
+    try {
+        await fs.mkdir(memoryDir, { recursive: true });
+        if (verbose) {
+            p.log.success('.memory/ directory ready');
+        }
+    }
+    catch { /* may already exist */ }
+}
+/**
+ * Migrate memory files from .docs/ to .memory/.
+ * One-time migration for existing users. Skips if destination exists (no clobber).
+ * Also cleans up ephemeral files from .docs/.
+ * Returns count of migrated files.
+ */
+export async function migrateMemoryFiles(verbose, cwd) {
+    const root = cwd ?? process.cwd();
+    const docsDir = path.join(root, '.docs');
+    const memoryDir = path.join(root, '.memory');
+    const migrations = [
+        { src: path.join(docsDir, 'WORKING-MEMORY.md'), dest: path.join(memoryDir, 'WORKING-MEMORY.md') },
+        { src: path.join(docsDir, 'patterns.md'), dest: path.join(memoryDir, 'PROJECT-PATTERNS.md') },
+        { src: path.join(docsDir, 'working-memory-backup.json'), dest: path.join(memoryDir, 'backup.json') },
+    ];
+    let migrated = 0;
+    for (const { src, dest } of migrations) {
+        try {
+            await fs.access(src);
+        }
+        catch {
+            continue; // Source doesn't exist
+        }
+        try {
+            await fs.access(dest);
+            continue; // Destination already exists — no clobber
+        }
+        catch {
+            // Destination doesn't exist — proceed with migration
+        }
+        try {
+            await fs.rename(src, dest);
+            migrated++;
+        }
+        catch {
+            // Cross-device or permission error — try copy+delete
+            try {
+                await fs.copyFile(src, dest);
+                await fs.rm(src, { force: true });
+                migrated++;
+            }
+            catch {
+                // Migration failed for this file — skip silently
+            }
+        }
+    }
+    // Clean up ephemeral files from .docs/
+    const ephemeralFiles = [
+        path.join(docsDir, '.working-memory-update.log'),
+        path.join(docsDir, '.working-memory-last-trigger'),
+    ];
+    for (const file of ephemeralFiles) {
+        try {
+            await fs.rm(file, { force: true });
+        }
+        catch { /* doesn't exist or can't remove */ }
+    }
+    // Clean up lock directory
+    try {
+        await fs.rmdir(path.join(docsDir, '.working-memory.lock'));
+    }
+    catch { /* doesn't exist or not empty */ }
+    if (migrated > 0 && verbose) {
+        p.log.success(`Migrated ${migrated} memory file(s) from .docs/ to .memory/`);
+    }
+    return migrated;
+}
 //# sourceMappingURL=post-install.js.map

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

@@ -1,4 +1,6 @@
 import type { Shell } from './safe-delete.js';
+/** Bump this when the safe-delete block changes. */
+export declare const SAFE_DELETE_BLOCK_VERSION = 2;
 /**
  * Generate the safe-delete shell function block with markers.
  * Returns null for unsupported shells.
@@ -13,6 +15,11 @@ export declare function isAlreadyInstalled(profilePath: string): Promise<boolean
  * Creates parent directories and the file if they don't exist.
  */
 export declare function installToProfile(profilePath: string, block: string): Promise<void>;
+/**
+ * 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 declare function getInstalledVersion(profilePath: string): Promise<number>;
 /**
  * Remove the safe-delete block from a profile file.
  * Returns true if the block was found and removed, false otherwise.

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

@@ -2,6 +2,8 @@ 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.
@@ -13,13 +15,18 @@ export function generateSafeDeleteBlock(shell, platform, trashCommand) {
         const cmd = trashCommand ?? 'trash';
         return [
             START_MARKER,
+            `# v${SAFE_DELETE_BLOCK_VERSION}`,
             `rm() {`,
             `  local files=()`,
             `  for arg in "$@"; do`,
             `    [[ "$arg" =~ ^- ]] || files+=("$arg")`,
             `  done`,
-            `  if (( \${#files[@]} > 0 )); then`,
-            `    ${cmd} "\${files[@]}"`,
+            `  local existing=()`,
+            `  for f in "\${files[@]}"; do`,
+            `    [ -e "$f" ] || [ -L "$f" ] && existing+=("$f")`,
+            `  done`,
+            `  if (( \${#existing[@]} > 0 )); then`,
+            `    ${cmd} "\${existing[@]}"`,
             `  fi`,
             `}`,
             `command() {`,
@@ -36,6 +43,7 @@ export function generateSafeDeleteBlock(shell, platform, trashCommand) {
         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`,
@@ -43,8 +51,14 @@ export function generateSafeDeleteBlock(shell, platform, trashCommand) {
             `      set files $files $arg`,
             `    end`,
             `  end`,
-            `  if test (count $files) -gt 0`,
-            `    ${cmd} $files`,
+            `  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,
@@ -54,6 +68,7 @@ export function generateSafeDeleteBlock(shell, platform, trashCommand) {
         if (platform === 'win32') {
             return [
                 START_MARKER,
+                `# v${SAFE_DELETE_BLOCK_VERSION}`,
                 `if (Get-Alias rm -ErrorAction SilentlyContinue) {`,
                 `  Remove-Alias rm -Force -Scope Global`,
                 `}`,
@@ -82,12 +97,14 @@ export function generateSafeDeleteBlock(shell, platform, trashCommand) {
         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 '-*' }`,
-            `  if ($files) { & ${cmd} @files }`,
+            `  $existing = $files | Where-Object { Test-Path $_ }`,
+            `  if ($existing) { & ${cmd} @existing }`,
             `}`,
             END_MARKER,
         ].join('\n');
@@ -123,6 +140,24 @@ export async function installToProfile(profilePath, block) {
     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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devflow-kit",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Agentic Development Toolkit for Claude Code - Enhance AI-assisted development with intelligent commands and workflows",
   "type": "module",
   "bin": {
@@ -24,6 +24,7 @@
     "dev": "tsc --watch",
     "cli": "node dist/cli.js",
     "prepublishOnly": "npm run build",
+    "version:bump": "npx tsx scripts/bump-version.ts",
     "test": "vitest run",
     "test:watch": "vitest"
   },

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

@@ -0,0 +1,15 @@
+{
+  "name": "devflow-accessibility",
+  "description": "Web accessibility patterns - WCAG compliance, ARIA roles, keyboard navigation, focus management",
+  "author": {
+    "name": "DevFlow Contributors",
+    "email": "dean@keren.dev"
+  },
+  "version": "1.2.0",
+  "homepage": "https://github.com/dean0x/devflow",
+  "repository": "https://github.com/dean0x/devflow",
+  "license": "MIT",
+  "keywords": ["accessibility", "wcag", "aria", "a11y"],
+  "agents": [],
+  "skills": ["accessibility"]
+}