devflow-kit 1.8.3 → 2.0.1

package/dist/plugins.js

@@ -1,233 +0,0 @@
-/**
- * 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 skills - foundation layer for all DevFlow plugins',
-        commands: [],
-        agents: [],
-        skills: ['core-patterns', 'docs-framework', 'git-safety', 'git-workflow', 'github-patterns', 'input-validation', 'search-first', 'test-driven-development', 'test-patterns'],
-    },
-    {
-        name: 'devflow-specify',
-        description: 'Interactive feature specification - creates well-defined GitHub issues',
-        commands: ['/specify'],
-        agents: ['skimmer', 'synthesizer'],
-        skills: ['agent-teams'],
-    },
-    {
-        name: 'devflow-implement',
-        description: 'Complete task implementation workflow with exploration, planning, and coding',
-        commands: ['/implement'],
-        agents: ['git', 'skimmer', 'synthesizer', 'coder', 'simplifier', 'scrutinizer', 'shepherd', 'validator'],
-        skills: ['agent-teams', 'implementation-patterns', 'knowledge-persistence', 'self-review'],
-    },
-    {
-        name: 'devflow-code-review',
-        description: 'Comprehensive code review with parallel specialized agents',
-        commands: ['/code-review'],
-        agents: ['git', 'reviewer', 'synthesizer'],
-        skills: ['agent-teams', 'architecture-patterns', 'complexity-patterns', 'consistency-patterns', 'database-patterns', 'dependencies-patterns', 'documentation-patterns', 'knowledge-persistence', 'performance-patterns', 'regression-patterns', 'review-methodology', 'security-patterns', 'test-patterns'],
-    },
-    {
-        name: 'devflow-resolve',
-        description: 'Process and fix code review issues with risk assessment',
-        commands: ['/resolve'],
-        agents: ['git', 'resolver', 'simplifier'],
-        skills: ['agent-teams', 'implementation-patterns', 'knowledge-persistence', 'security-patterns'],
-    },
-    {
-        name: 'devflow-debug',
-        description: 'Debugging workflows with competing hypothesis investigation using agent teams',
-        commands: ['/debug'],
-        agents: ['git', 'synthesizer'],
-        skills: ['agent-teams', 'git-safety', 'knowledge-persistence'],
-    },
-    {
-        name: 'devflow-self-review',
-        description: 'Self-review workflow: Simplifier + Scrutinizer for code quality',
-        commands: ['/self-review'],
-        agents: ['simplifier', 'scrutinizer', 'validator'],
-        skills: ['self-review', 'core-patterns'],
-    },
-    {
-        name: 'devflow-ambient',
-        description: 'Ambient mode — intent classification with proportional agent orchestration',
-        commands: ['/ambient'],
-        agents: ['coder', 'validator', 'simplifier', 'scrutinizer', 'shepherd', 'skimmer', 'reviewer'],
-        skills: ['ambient-router', 'implementation-orchestration', 'debug-orchestration', 'plan-orchestration'],
-    },
-    {
-        name: 'devflow-audit-claude',
-        description: 'Audit CLAUDE.md files against Anthropic best practices',
-        commands: ['/audit-claude'],
-        agents: ['claude-md-auditor'],
-        skills: [],
-        optional: true,
-    },
-    {
-        name: 'devflow-typescript',
-        description: 'TypeScript language patterns - type safety, generics, utility types, type guards',
-        commands: [],
-        agents: [],
-        skills: ['typescript'],
-        optional: true,
-    },
-    {
-        name: 'devflow-react',
-        description: 'React framework patterns - hooks, state management, composition, performance',
-        commands: [],
-        agents: [],
-        skills: ['react'],
-        optional: true,
-    },
-    {
-        name: 'devflow-accessibility',
-        description: 'Web accessibility patterns - WCAG compliance, ARIA roles, keyboard navigation, focus management',
-        commands: [],
-        agents: [],
-        skills: ['accessibility'],
-        optional: true,
-    },
-    {
-        name: 'devflow-frontend-design',
-        description: 'Frontend design patterns - typography, color systems, spacing, motion, responsive design',
-        commands: [],
-        agents: [],
-        skills: ['frontend-design'],
-        optional: true,
-    },
-    {
-        name: 'devflow-go',
-        description: 'Go language patterns - error handling, interfaces, concurrency, package design',
-        commands: [],
-        agents: [],
-        skills: ['go'],
-        optional: true,
-    },
-    {
-        name: 'devflow-java',
-        description: 'Java language patterns - records, sealed classes, composition, modern Java features',
-        commands: [],
-        agents: [],
-        skills: ['java'],
-        optional: true,
-    },
-    {
-        name: 'devflow-python',
-        description: 'Python language patterns - type hints, protocols, dataclasses, async programming',
-        commands: [],
-        agents: [],
-        skills: ['python'],
-        optional: true,
-    },
-    {
-        name: 'devflow-rust',
-        description: 'Rust language patterns - ownership, borrowing, error handling, type-driven design',
-        commands: [],
-        agents: [],
-        skills: ['rust'],
-        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

@@ -1,5 +0,0 @@
-/**
- * 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

@@ -1,14 +0,0 @@
-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/git.d.ts

@@ -1,11 +0,0 @@
-/**
- * Get git repository root directory (async, non-blocking)
- * Returns null if not in a git repository
- *
- * Security: Validates output to prevent command injection
- * - Rejects paths with injection characters (newlines, semicolons, shell operators)
- * - Ensures path is absolute
- * - Resolves path canonically
- */
-export declare function getGitRoot(): Promise<string | null>;
-//# sourceMappingURL=git.d.ts.map

package/dist/utils/git.js

@@ -1,36 +0,0 @@
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import * as path from 'path';
-const execAsync = promisify(exec);
-/**
- * Get git repository root directory (async, non-blocking)
- * Returns null if not in a git repository
- *
- * Security: Validates output to prevent command injection
- * - Rejects paths with injection characters (newlines, semicolons, shell operators)
- * - Ensures path is absolute
- * - Resolves path canonically
- */
-export async function getGitRoot() {
-    try {
-        const { stdout } = await execAsync('git rev-parse --show-toplevel', {
-            cwd: process.cwd(),
-            encoding: 'utf-8'
-        });
-        const gitRootRaw = stdout.trim();
-        // Validate git root path (security: prevent injection)
-        if (!gitRootRaw || gitRootRaw.includes('\n') || gitRootRaw.includes(';') || gitRootRaw.includes('&&')) {
-            return null;
-        }
-        // Validate it's an absolute path
-        const gitRoot = path.resolve(gitRootRaw);
-        if (!path.isAbsolute(gitRoot)) {
-            return null;
-        }
-        return gitRoot;
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=git.js.map

package/dist/utils/installer.d.ts

@@ -1,41 +0,0 @@
-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

@@ -1,195 +0,0 @@
-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) {
-            // Skip cleanup for shadowed skills — user has a personal override
-            const shadowDir = path.join(devflowDir, 'skills', skill);
-            try {
-                const stat = await fs.stat(shadowDir);
-                if (stat.isDirectory())
-                    continue;
-            }
-            catch { /* no shadow — proceed with cleanup */ }
-            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, respects shadows)
-        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) {
-                        // Skip copy for shadowed skills — user has a personal override
-                        const shadowDir = path.join(devflowDir, 'skills', skillDir.name);
-                        try {
-                            const stat = await fs.stat(shadowDir);
-                            if (stat.isDirectory())
-                                continue;
-                        }
-                        catch { /* no shadow — proceed with copy */ }
-                        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);
-        if (process.platform !== 'win32') {
-            await chmodRecursive(scriptsTarget, 0o755);
-        }
-    }
-    catch { /* scripts may not exist */ }
-    spinner.stop('Components installed via file copy');
-}
-//# sourceMappingURL=installer.js.map

package/dist/utils/manifest.d.ts

@@ -1,46 +0,0 @@
-/**
- * Manifest data tracked for each DevFlow installation.
- */
-export interface ManifestData {
-    version: string;
-    plugins: string[];
-    scope: 'user' | 'local';
-    features: {
-        teams: boolean;
-        ambient: boolean;
-        memory: boolean;
-        hud?: boolean;
-    };
-    installedAt: string;
-    updatedAt: string;
-}
-/**
- * Read and parse the manifest file. Returns null if missing or corrupt.
- */
-export declare function readManifest(devflowDir: string): Promise<ManifestData | null>;
-/**
- * Write manifest to disk. Creates parent directory if needed.
- */
-export declare function writeManifest(devflowDir: string, data: ManifestData): Promise<void>;
-/**
- * Merge new plugins into existing plugin list (union, no duplicates).
- * Preserves order: existing plugins first, then new ones appended.
- */
-export declare function mergeManifestPlugins(existing: string[], newPlugins: string[]): string[];
-/**
- * Detect upgrade/downgrade/same version status.
- */
-export interface UpgradeInfo {
-    isUpgrade: boolean;
-    isDowngrade: boolean;
-    isSameVersion: boolean;
-    previousVersion: string | null;
-}
-/**
- * Resolve the final plugin list for a manifest write.
- * On partial installs (--plugin flag), merge newly installed plugins into
- * the existing manifest's plugin list. On full installs, replace entirely.
- */
-export declare function resolvePluginList(installedPluginNames: string[], existingManifest: ManifestData | null, isPartialInstall: boolean): string[];
-export declare function detectUpgrade(currentVersion: string, installedVersion: string | null): UpgradeInfo;
-//# sourceMappingURL=manifest.d.ts.map

package/dist/utils/manifest.js

@@ -1,100 +0,0 @@
-import { promises as fs } from 'fs';
-import * as path from 'path';
-/**
- * Read and parse the manifest file. Returns null if missing or corrupt.
- */
-export async function readManifest(devflowDir) {
-    const manifestPath = path.join(devflowDir, 'manifest.json');
-    try {
-        const content = await fs.readFile(manifestPath, 'utf-8');
-        const data = JSON.parse(content);
-        if (!data.version ||
-            !Array.isArray(data.plugins) ||
-            !data.scope ||
-            typeof data.features !== 'object' ||
-            data.features === null ||
-            typeof data.features.teams !== 'boolean' ||
-            typeof data.features.ambient !== 'boolean' ||
-            typeof data.features.memory !== 'boolean' ||
-            typeof data.installedAt !== 'string' ||
-            typeof data.updatedAt !== 'string') {
-            return null;
-        }
-        return data;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Write manifest to disk. Creates parent directory if needed.
- */
-export async function writeManifest(devflowDir, data) {
-    await fs.mkdir(devflowDir, { recursive: true });
-    const manifestPath = path.join(devflowDir, 'manifest.json');
-    await fs.writeFile(manifestPath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
-}
-/**
- * Merge new plugins into existing plugin list (union, no duplicates).
- * Preserves order: existing plugins first, then new ones appended.
- */
-export function mergeManifestPlugins(existing, newPlugins) {
-    const merged = [...existing];
-    for (const plugin of newPlugins) {
-        if (!merged.includes(plugin)) {
-            merged.push(plugin);
-        }
-    }
-    return merged;
-}
-/**
- * Compare two semver strings. Returns -1, 0, or 1.
- * Handles simple x.y.z versions; returns null for unparseable input.
- *
- * Note: Pre-release suffixes (e.g., `-beta.1`, `-rc.2`) are silently ignored.
- * `1.0.0-beta.1` and `1.0.0` compare as equal. Build metadata is also ignored.
- */
-function compareSemver(a, b) {
-    const parse = (v) => {
-        const match = v.match(/^v?(\d+)\.(\d+)\.(\d+)/);
-        return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : [];
-    };
-    const pa = parse(a);
-    const pb = parse(b);
-    if (pa.length === 0 || pb.length === 0)
-        return null;
-    for (let i = 0; i < 3; i++) {
-        if (pa[i] > pb[i])
-            return 1;
-        if (pa[i] < pb[i])
-            return -1;
-    }
-    return 0;
-}
-/**
- * Resolve the final plugin list for a manifest write.
- * On partial installs (--plugin flag), merge newly installed plugins into
- * the existing manifest's plugin list. On full installs, replace entirely.
- */
-export function resolvePluginList(installedPluginNames, existingManifest, isPartialInstall) {
-    if (existingManifest && isPartialInstall) {
-        return mergeManifestPlugins(existingManifest.plugins, installedPluginNames);
-    }
-    return installedPluginNames;
-}
-export function detectUpgrade(currentVersion, installedVersion) {
-    if (!installedVersion) {
-        return { isUpgrade: false, isDowngrade: false, isSameVersion: false, previousVersion: null };
-    }
-    const cmp = compareSemver(currentVersion, installedVersion);
-    if (cmp === null) {
-        return { isUpgrade: false, isDowngrade: false, isSameVersion: false, previousVersion: installedVersion };
-    }
-    return {
-        isUpgrade: cmp > 0,
-        isDowngrade: cmp < 0,
-        isSameVersion: cmp === 0,
-        previousVersion: installedVersion,
-    };
-}
-//# sourceMappingURL=manifest.js.map