devflow-kit 0.9.0 → 1.1.0

package/dist/plugins.js

@@ -0,0 +1,169 @@
+/**
+ * Shared plugin registry — single source of truth for all CLI commands.
+ */
+/**
+ * Available DevFlow plugins
+ */
+export const DEVFLOW_PLUGINS = [
+    {
+        name: 'devflow-core-skills',
+        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-driven-development', 'test-patterns', 'typescript'],
+    },
+    {
+        name: 'devflow-specify',
+        description: 'Interactive feature specification',
+        commands: ['/specify'],
+        agents: ['skimmer', 'synthesizer'],
+        skills: ['agent-teams'],
+    },
+    {
+        name: 'devflow-implement',
+        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'],
+    },
+    {
+        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'],
+    },
+    {
+        name: 'devflow-resolve',
+        description: 'Process and fix review issues',
+        commands: ['/resolve'],
+        agents: ['git', 'resolver', 'simplifier'],
+        skills: ['agent-teams', 'implementation-patterns', 'security-patterns'],
+    },
+    {
+        name: 'devflow-debug',
+        description: 'Debugging with competing hypotheses',
+        commands: ['/debug'],
+        agents: ['git'],
+        skills: ['agent-teams', 'git-safety'],
+    },
+    {
+        name: 'devflow-self-review',
+        description: 'Self-review workflow (Simplifier + Scrutinizer)',
+        commands: ['/self-review'],
+        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',
+        commands: ['/audit-claude'],
+        agents: ['claude-md-auditor'],
+        skills: [],
+        optional: true,
+    },
+];
+/**
+ * Deprecated command names from old installations.
+ * Used during init to clean up stale command files on upgrade.
+ */
+export const LEGACY_COMMAND_NAMES = [
+    'review',
+];
+/**
+ * Deprecated skill names from old installations (prefixed with devflow-).
+ * Used during uninstall to clean up legacy installs.
+ */
+export const LEGACY_SKILL_NAMES = [
+    'devflow-core-patterns',
+    'devflow-review-methodology',
+    'devflow-docs-framework',
+    'devflow-git-safety',
+    'devflow-github-patterns',
+    'devflow-implementation-patterns',
+    'devflow-codebase-navigation',
+    'devflow-test-design',
+    'devflow-code-smell',
+    'devflow-commit',
+    'devflow-pull-request',
+    'devflow-input-validation',
+    'devflow-self-review',
+    'devflow-typescript',
+    'devflow-react',
+    'devflow-architecture-patterns',
+    'devflow-complexity-patterns',
+    'devflow-consistency-patterns',
+    'devflow-database-patterns',
+    'devflow-dependencies-patterns',
+    'devflow-documentation-patterns',
+    'devflow-performance-patterns',
+    'devflow-regression-patterns',
+    'devflow-security-patterns',
+    'devflow-tests-patterns',
+    'devflow-pattern-check',
+    'devflow-error-handling',
+    'devflow-debug',
+    'devflow-accessibility',
+    'devflow-frontend-design',
+    'devflow-agent-teams',
+    // v1.0.0 consolidation: old unprefixed names from pre-v1.0.0 installs
+    'codebase-navigation',
+    'test-design',
+    'code-smell',
+    'commit',
+    'pull-request',
+    'tests-patterns',
+];
+/**
+ * Derive unique skill names from all plugins.
+ */
+export function getAllSkillNames() {
+    const skills = new Set();
+    for (const plugin of DEVFLOW_PLUGINS) {
+        for (const skill of plugin.skills) {
+            skills.add(skill);
+        }
+    }
+    return [...skills];
+}
+/**
+ * Derive unique agent names from all plugins.
+ */
+export function getAllAgentNames() {
+    const agents = new Set();
+    for (const plugin of DEVFLOW_PLUGINS) {
+        for (const agent of plugin.agents) {
+            agents.add(agent);
+        }
+    }
+    return [...agents];
+}
+/**
+ * Build maps of unique assets to their source plugin (first plugin that declares them).
+ * This ensures each skill/agent is copied only once during installation.
+ */
+export function buildAssetMaps(plugins) {
+    const skillsMap = new Map();
+    const agentsMap = new Map();
+    for (const plugin of plugins) {
+        for (const skill of plugin.skills) {
+            if (!skillsMap.has(skill)) {
+                skillsMap.set(skill, plugin.name);
+            }
+        }
+        for (const agent of plugin.agents) {
+            if (!agentsMap.has(agent)) {
+                agentsMap.set(agent, plugin.name);
+            }
+        }
+    }
+    return { skillsMap, agentsMap };
+}
+//# sourceMappingURL=plugins.js.map

package/dist/utils/cli.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Check if Claude CLI is available in the system PATH
+ */
+export declare function isClaudeCliAvailable(): boolean;
+//# sourceMappingURL=cli.d.ts.map

package/dist/utils/cli.js

@@ -0,0 +1,14 @@
+import { execSync } from 'child_process';
+/**
+ * Check if Claude CLI is available in the system PATH
+ */
+export function isClaudeCliAvailable() {
+    try {
+        execSync('claude --version', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=cli.js.map

package/dist/utils/installer.d.ts

@@ -0,0 +1,41 @@
+import type { PluginDefinition } from '../plugins.js';
+/**
+ * Minimal spinner interface matching @clack/prompts spinner().
+ */
+export interface Spinner {
+    start(msg?: string): void;
+    stop(msg?: string, code?: number): void;
+    message(msg?: string): void;
+}
+/**
+ * Recursively copy a directory tree.
+ */
+export declare function copyDirectory(src: string, dest: string): Promise<void>;
+/**
+ * Recursively chmod all files in a directory tree.
+ */
+export declare function chmodRecursive(dir: string, mode: number): Promise<void>;
+/**
+ * Install plugins via Claude CLI native plugin system.
+ * Returns true if all plugins installed successfully.
+ */
+export declare function installViaCli(plugins: PluginDefinition[], scope: 'user' | 'local', spinner: Spinner): boolean;
+export interface FileCopyOptions {
+    plugins: PluginDefinition[];
+    claudeDir: string;
+    pluginsDir: string;
+    rootDir: string;
+    devflowDir: string;
+    skillsMap: Map<string, string>;
+    agentsMap: Map<string, string>;
+    isPartialInstall: boolean;
+    teamsEnabled: boolean;
+    spinner: Spinner;
+}
+/**
+ * Install plugins via manual file copy.
+ * Handles cleanup of old monolithic structure, deduplication of shared assets,
+ * and script installation with executable permissions.
+ */
+export declare function installViaFileCopy(options: FileCopyOptions): Promise<void>;
+//# sourceMappingURL=installer.d.ts.map

package/dist/utils/installer.js

@@ -0,0 +1,177 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import { DEVFLOW_PLUGINS } from '../plugins.js';
+/**
+ * Recursively copy a directory tree.
+ */
+export async function copyDirectory(src, dest) {
+    await fs.mkdir(dest, { recursive: true });
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirectory(srcPath, destPath);
+        }
+        else {
+            await fs.copyFile(srcPath, destPath);
+        }
+    }
+}
+/**
+ * Recursively chmod all files in a directory tree.
+ */
+export async function chmodRecursive(dir, mode) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await chmodRecursive(fullPath, mode);
+        }
+        else if (entry.isFile()) {
+            await fs.chmod(fullPath, mode);
+        }
+    }
+}
+/**
+ * Add DevFlow marketplace to Claude CLI.
+ * Idempotent — safe to call multiple times.
+ */
+function addMarketplaceViaCli() {
+    try {
+        execSync('claude plugin marketplace add dean0x/devflow', { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Install a single plugin via Claude CLI.
+ */
+function installPluginViaCli(pluginName, scope) {
+    try {
+        const cliScope = scope === 'local' ? 'project' : 'user';
+        execSync(`claude plugin install ${pluginName}@dean0x-devflow --scope ${cliScope}`, {
+            stdio: 'pipe',
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Install plugins via Claude CLI native plugin system.
+ * Returns true if all plugins installed successfully.
+ */
+export function installViaCli(plugins, scope, spinner) {
+    spinner.message('Adding DevFlow marketplace...');
+    const marketplaceAdded = addMarketplaceViaCli();
+    if (!marketplaceAdded)
+        return false;
+    spinner.message('Installing plugins via Claude CLI...');
+    for (const plugin of plugins) {
+        if (!installPluginViaCli(plugin.name, scope))
+            return false;
+    }
+    spinner.stop('Plugins installed via Claude CLI');
+    return true;
+}
+/**
+ * Install plugins via manual file copy.
+ * Handles cleanup of old monolithic structure, deduplication of shared assets,
+ * and script installation with executable permissions.
+ */
+export async function installViaFileCopy(options) {
+    const { plugins, claudeDir, pluginsDir, rootDir, devflowDir, skillsMap, agentsMap, isPartialInstall, teamsEnabled, spinner, } = options;
+    // Clean old DevFlow files before installing (only for full install)
+    if (!isPartialInstall) {
+        const oldDirs = [
+            path.join(claudeDir, 'commands', 'devflow'),
+            path.join(claudeDir, 'agents', 'devflow'),
+        ];
+        for (const dir of oldDirs) {
+            try {
+                await fs.rm(dir, { recursive: true, force: true });
+            }
+            catch { /* ignore */ }
+        }
+        const allSkills = new Set();
+        for (const plugin of DEVFLOW_PLUGINS) {
+            for (const skill of plugin.skills) {
+                allSkills.add(skill);
+            }
+        }
+        for (const skill of allSkills) {
+            try {
+                await fs.rm(path.join(claudeDir, 'skills', skill), { recursive: true, force: true });
+            }
+            catch { /* ignore */ }
+        }
+    }
+    // Install each selected plugin (with deduplication)
+    for (const plugin of plugins) {
+        const pluginSourceDir = path.join(pluginsDir, plugin.name);
+        // Install commands (variant-aware: pick -teams.md or base .md)
+        const commandsSource = path.join(pluginSourceDir, 'commands');
+        const commandsTarget = path.join(claudeDir, 'commands', 'devflow');
+        try {
+            const allFiles = await fs.readdir(commandsSource);
+            const mdFiles = allFiles.filter(f => f.endsWith('.md'));
+            const teamsVariants = new Set(mdFiles.filter(f => f.endsWith('-teams.md')));
+            const baseCommands = mdFiles.filter(f => !teamsVariants.has(f));
+            if (baseCommands.length > 0 || teamsVariants.size > 0) {
+                await fs.mkdir(commandsTarget, { recursive: true });
+                for (const file of baseCommands) {
+                    const teamsFile = file.replace('.md', '-teams.md');
+                    const sourceFile = (teamsEnabled && teamsVariants.has(teamsFile)) ? teamsFile : file;
+                    await fs.copyFile(path.join(commandsSource, sourceFile), path.join(commandsTarget, file));
+                }
+            }
+        }
+        catch { /* no commands directory */ }
+        // Install agents (deduplicated)
+        const agentsSource = path.join(pluginSourceDir, 'agents');
+        const agentsTarget = path.join(claudeDir, 'agents', 'devflow');
+        try {
+            const files = await fs.readdir(agentsSource);
+            if (files.length > 0) {
+                await fs.mkdir(agentsTarget, { recursive: true });
+                for (const file of files) {
+                    const agentName = path.basename(file, '.md');
+                    if (agentsMap.get(agentName) === plugin.name) {
+                        await fs.copyFile(path.join(agentsSource, file), path.join(agentsTarget, file));
+                    }
+                }
+            }
+        }
+        catch { /* no agents directory */ }
+        // Install skills (deduplicated)
+        const skillsSource = path.join(pluginSourceDir, 'skills');
+        try {
+            const skillDirs = await fs.readdir(skillsSource, { withFileTypes: true });
+            for (const skillDir of skillDirs) {
+                if (skillDir.isDirectory()) {
+                    if (skillsMap.get(skillDir.name) === plugin.name) {
+                        const skillTarget = path.join(claudeDir, 'skills', skillDir.name);
+                        await copyDirectory(path.join(skillsSource, skillDir.name), skillTarget);
+                    }
+                }
+            }
+        }
+        catch { /* no skills directory */ }
+    }
+    // Install scripts (always from root scripts/ directory)
+    const scriptsSource = path.join(rootDir, 'scripts');
+    const scriptsTarget = path.join(devflowDir, 'scripts');
+    try {
+        await fs.mkdir(scriptsTarget, { recursive: true });
+        await copyDirectory(scriptsSource, scriptsTarget);
+        await chmodRecursive(scriptsTarget, 0o755);
+    }
+    catch { /* scripts may not exist */ }
+    spinner.stop('Components installed via file copy');
+}
+//# sourceMappingURL=installer.js.map

package/dist/utils/paths.d.ts

@@ -1,3 +1,12 @@
+/**
+ * Get the OS-specific path for Claude Code managed settings.
+ * Managed settings have highest precedence and cannot be overridden by users.
+ * - macOS: /Library/Application Support/ClaudeCode/managed-settings.json
+ * - Linux: /etc/claude-code/managed-settings.json
+ *
+ * @throws {Error} On unsupported platforms (Windows)
+ */
+export declare function getManagedSettingsPath(): string;
 /**
  * Get home directory with proper fallback and validation
  * Priority: process.env.HOME > os.homedir()
@@ -28,5 +37,6 @@ export declare function getDevFlowDirectory(): string;
 export declare function getInstallationPaths(scope: 'user' | 'local'): Promise<{
     claudeDir: string;
     devflowDir: string;
+    gitRoot: string | null;
 }>;
 //# sourceMappingURL=paths.d.ts.map

package/dist/utils/paths.js

@@ -1,6 +1,24 @@
-import { homedir } from 'os';
+import { homedir, platform } from 'os';
 import * as path from 'path';
 import { getGitRoot } from './git.js';
+/**
+ * Get the OS-specific path for Claude Code managed settings.
+ * Managed settings have highest precedence and cannot be overridden by users.
+ * - macOS: /Library/Application Support/ClaudeCode/managed-settings.json
+ * - Linux: /etc/claude-code/managed-settings.json
+ *
+ * @throws {Error} On unsupported platforms (Windows)
+ */
+export function getManagedSettingsPath() {
+    const os = platform();
+    if (os === 'darwin') {
+        return '/Library/Application Support/ClaudeCode/managed-settings.json';
+    }
+    if (os === 'linux') {
+        return '/etc/claude-code/managed-settings.json';
+    }
+    throw new Error(`Managed settings not supported on platform: ${os}`);
+}
 /**
  * Get home directory with proper fallback and validation
  * Priority: process.env.HOME > os.homedir()
@@ -68,7 +86,8 @@ export async function getInstallationPaths(scope) {
     if (scope === 'user') {
         return {
             claudeDir: getClaudeDirectory(),
-            devflowDir: getDevFlowDirectory()
+            devflowDir: getDevFlowDirectory(),
+            gitRoot: null,
         };
     }
     else {
@@ -79,7 +98,8 @@ export async function getInstallationPaths(scope) {
         }
         return {
             claudeDir: path.join(gitRoot, '.claude'),
-            devflowDir: path.join(gitRoot, '.devflow')
+            devflowDir: path.join(gitRoot, '.devflow'),
+            gitRoot,
         };
     }
 }

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

@@ -0,0 +1,80 @@
+/**
+ * Replace ${DEVFLOW_DIR} placeholders in a settings template.
+ */
+export declare function substituteSettingsTemplate(template: string, devflowDir: string): string;
+/**
+ * Add Agent Teams configuration to settings JSON.
+ * Sets teammateMode and CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS env var.
+ */
+export declare function applyTeamsConfig(settingsJson: string): string;
+/**
+ * Remove Agent Teams configuration from settings JSON.
+ * Strips teammateMode and CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS env var.
+ */
+export declare function stripTeamsConfig(settingsJson: string): string;
+/**
+ * Compute which entries need appending to a .gitignore file.
+ * Returns only entries not already present.
+ */
+export declare function computeGitignoreAppend(existingContent: string, entries: string[]): string[];
+/**
+ * Merge DevFlow deny entries into an existing managed settings object.
+ * Preserves existing entries, deduplicates, and returns the merged JSON string.
+ */
+export declare function mergeDenyList(existingJson: string, newDenyEntries: string[]): string;
+/**
+ * Attempt to install managed settings (security deny list) to the system path.
+ * Managed settings have highest precedence in Claude Code and cannot be overridden.
+ *
+ * Strategy:
+ * 1. Try direct write (works if running as root or directory is writable)
+ * 2. If EACCES in TTY, offer to retry with sudo
+ * 3. Returns true if managed settings were written, false if caller should fall back
+ */
+export declare function installManagedSettings(rootDir: string, verbose: boolean): Promise<boolean>;
+/**
+ * Remove DevFlow deny entries from managed settings.
+ * If only DevFlow entries remain, deletes the file entirely.
+ *
+ * Mirrors installManagedSettings strategy:
+ * 1. Try direct write/delete
+ * 2. If EACCES and TTY, ask user before sudo
+ * 3. Non-TTY: return false (caller logs preservation message)
+ */
+export declare function removeManagedSettings(rootDir: string, verbose: boolean): Promise<boolean>;
+export type SecurityMode = 'managed' | 'user';
+/**
+ * Install or update settings.json with DevFlow configuration.
+ * Prompts interactively in TTY mode when settings already exist.
+ * In non-TTY mode, skips override (safe default).
+ *
+ * When securityMode is 'managed', the deny list goes to system-level managed
+ * settings and is excluded from user settings.json. When 'user', the deny list
+ * is included in settings.json (original behavior).
+ */
+export declare function installSettings(claudeDir: string, rootDir: string, devflowDir: string, verbose: boolean, teamsEnabled?: boolean, securityMode?: SecurityMode): Promise<void>;
+/**
+ * Create .claudeignore in git repository root (skip if already exists).
+ */
+export declare function installClaudeignore(gitRoot: string, rootDir: string, verbose: boolean): Promise<void>;
+/**
+ * Update .gitignore with DevFlow entries (for local scope installs).
+ */
+export declare function updateGitignore(gitRoot: string, verbose: boolean): Promise<void>;
+/**
+ * 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