@hongmaple0820/scale-engine 0.33.0 → 0.39.0

package/dist/bootstrap/DependencyBootstrap.js

@@ -0,0 +1,829 @@
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { execa, execaSync } from 'execa';
+import { inspectCodeIntelligence, writeCodeIntelligenceConfig } from '../codegraph/CodeIntelligence.js';
+import { externalCommandExists } from '../core/ExternalCommand.js';
+import { inspectMemoryProviders, useMemoryProvider, writeMemoryProvidersConfig } from '../memory/MemoryProviders.js';
+import { wrapShellCommandWithRtk } from '../tools/RtkRuntime.js';
+import { inspectToolCapabilities } from '../tools/ToolCapabilityRegistry.js';
+const UI_SKILL_INSTALLS = {
+    'awesome-design-md': (ctx) => {
+        const installDir = quotePath(join(ctx.homeDir, '.scale', 'vendor', 'awesome-design-md'));
+        return `npx degit VoltAgent/awesome-design-md ${installDir}`;
+    },
+    'ui-ux-pro-max': 'npx uipro-cli init --ai codex',
+    'frontend-design': 'npx skills add anthropics/skills --skill frontend-design',
+};
+const RTK_INSTALL = 'cargo install --git https://github.com/rtk-ai/rtk';
+const CODEGRAPH_INSTALL = 'npm install -g @colbymchenry/codegraph';
+const GRAPHIFY_UV_INSTALL = 'uv tool install graphify && graphify install --platform codex';
+const GRAPHIFY_PIPX_INSTALL = 'pipx install graphify && graphify install --platform codex';
+const GRAPHIFY_PIP_INSTALL = 'pip install graphify && graphify install --platform codex';
+const GRAPHIFY_PIP3_INSTALL = 'pip3 install graphify && graphify install --platform codex';
+const GRAPHIFY_PYTHON_INSTALL = 'python -m pip install graphify && graphify install --platform codex';
+const GRAPHIFY_PYTHON3_INSTALL = 'python3 -m pip install graphify && graphify install --platform codex';
+const GBRAIN_INSTALL = 'bun install -g github:garrytan/gbrain && gbrain init --pglite';
+const GBRAIN_SOURCE = 'https://github.com/garrytan/gbrain';
+const DEPENDENCY_BOOTSTRAP_DEFINITIONS = [
+    {
+        id: 'awesome-design-md',
+        name: 'Awesome Design.md',
+        kind: 'skill',
+        packs: ['ui'],
+        source: 'https://github.com/VoltAgent/awesome-design-md',
+        detectSkillId: 'awesome-design-md',
+        detectPaths: ctx => [join(ctx.homeDir, '.scale', 'vendor', 'awesome-design-md', 'README.md')],
+        prerequisites: ['npx'],
+        manualReason: 'Requires npm/npx to sync the upstream DESIGN.md catalog that drives brand and visual-language decisions.',
+        installCommand: ctx => ctx.commandExists('npx') ? UI_SKILL_INSTALLS['awesome-design-md'](ctx) : null,
+    },
+    {
+        id: 'ui-ux-pro-max',
+        name: 'UI/UX Pro Max',
+        kind: 'skill',
+        packs: ['ui'],
+        source: 'https://github.com/nextlevelbuilder/ui-ux-pro-max-skill',
+        detectSkillId: 'ui-ux-pro-max',
+        prerequisites: ['npx'],
+        manualReason: 'Requires npm/npx so the official uipro-cli installer can configure the UX, state, accessibility, and responsive-review skill.',
+        installCommand: ctx => ctx.commandExists('npx') ? UI_SKILL_INSTALLS['ui-ux-pro-max'] : null,
+    },
+    {
+        id: 'frontend-design',
+        name: 'Frontend Design',
+        kind: 'skill',
+        packs: [],
+        source: 'https://github.com/anthropics/skills/tree/main/skills/frontend-design',
+        detectSkillId: 'frontend-design',
+        prerequisites: ['npx'],
+        manualReason: 'Optional implementation companion only; awesome-design-md and ui-ux-pro-max are the default UI stack.',
+        installCommand: ctx => ctx.commandExists('npx') ? UI_SKILL_INSTALLS['frontend-design'] : null,
+    },
+    {
+        id: 'rtk',
+        name: 'RTK',
+        kind: 'cli',
+        packs: ['external-cli'],
+        source: 'https://github.com/rtk-ai/rtk',
+        detectCommand: 'rtk',
+        prerequisites: ['cargo'],
+        manualReason: 'RTK currently installs from the official Rust toolchain path and needs Cargo on PATH.',
+        installCommand: ctx => ctx.commandExists('cargo') ? RTK_INSTALL : null,
+        healthCheck: checkRtkHealth,
+    },
+    {
+        id: 'gbrain',
+        name: 'GBrain',
+        kind: 'cli',
+        packs: ['memory'],
+        source: GBRAIN_SOURCE,
+        detectCommand: 'gbrain',
+        prerequisites: ['bun'],
+        manualReason: 'The official standalone GBrain install needs Bun and then a configured brain (`gbrain init --pglite`) before cross-session recall is usable.',
+        installCommand: ctx => buildGbrainInstallCommand(ctx),
+        healthCheck: checkGbrainHealth,
+    },
+    {
+        id: 'graphify',
+        name: 'Graphify',
+        kind: 'cli',
+        packs: ['knowledge'],
+        source: 'https://github.com/safishamsi/graphify',
+        detectCommand: 'graphify',
+        prerequisites: ['uv|pipx|pip|pip3|python|python3'],
+        manualReason: 'Graphify requires Python 3.10+ and a supported installer; uv tool install is preferred to avoid polluting project virtualenvs.',
+        installCommand: ctx => buildGraphifyInstallCommand(ctx),
+        healthCheck: checkGraphifyHealth,
+    },
+    {
+        id: 'codegraph',
+        name: 'CodeGraph',
+        kind: 'cli',
+        packs: ['knowledge'],
+        source: 'https://github.com/colbymchenry/codegraph',
+        detectCommand: 'codegraph',
+        prerequisites: ['npm'],
+        manualReason: 'CodeGraph installs through npm and needs Node.js/npm available on PATH.',
+        installCommand: ctx => ctx.commandExists('npm') ? CODEGRAPH_INSTALL : null,
+        healthCheck: checkCodeGraphHealth,
+    },
+];
+export async function bootstrapDependencies(options = {}) {
+    const projectDir = resolve(options.projectDir ?? process.cwd());
+    const scaleDir = resolveScaleRoot(projectDir, options.scaleDir);
+    const homeDir = homedir();
+    const packIds = normalizePackIds(options.packIds);
+    const includeIds = unique((options.includeIds ?? []).map(value => value.trim()).filter(Boolean));
+    const definitions = selectDefinitions(packIds, includeIds);
+    const context = {
+        projectDir,
+        homeDir,
+        commandExists: externalCommandExists,
+    };
+    const reports = definitions.map(definition => inspectDefinition(definition, context));
+    const runtimeChecks = buildRuntimeChecks(reports);
+    if (options.apply) {
+        for (const item of reports.filter(entry => entry.status === 'ready')) {
+            if (!item.installCommand)
+                continue;
+            const result = await runInstallCommand(item.installCommand);
+            item.output = result.output;
+            item.error = result.error;
+            const definition = definitions.find(entry => entry.id === item.id);
+            const rechecked = definition ? inspectDefinition(definition, context) : item;
+            item.installed = rechecked.installed;
+            item.detectedBy = rechecked.detectedBy;
+            item.health = rechecked.health;
+            item.status = result.ok && rechecked.installed
+                ? rechecked.status === 'installed' ? 'installed-now' : rechecked.status
+                : 'failed';
+            if (!result.ok && !item.error)
+                item.error = `Installation command failed: ${item.installCommand}`;
+            if (!result.ok)
+                item.installSupported = true;
+        }
+    }
+    const postActions = options.apply ? applyDependencyBootstrapPostActions(projectDir, scaleDir, reports) : [];
+    const postChecks = options.apply
+        ? runDependencyBootstrapPostChecks({ projectDir, scaleDir, packIds, items: reports, homeDir })
+        : [];
+    return buildReport(projectDir, scaleDir, packIds, includeIds, Boolean(options.apply), runtimeChecks, reports, postActions, postChecks);
+}
+function buildReport(projectDir, scaleDir, packIds, includeIds, apply, runtimeChecks, items, postActions, postChecks) {
+    const summary = {
+        total: items.length,
+        installed: items.filter(item => item.status === 'installed').length,
+        ready: items.filter(item => item.status === 'ready').length,
+        manualReview: items.filter(item => item.status === 'manual-review').length,
+        needsInit: items.filter(item => item.status === 'needs-init').length,
+        versionDrift: items.filter(item => item.status === 'version-drift').length,
+        installedNow: items.filter(item => item.status === 'installed-now').length,
+        failed: items.filter(item => item.status === 'failed').length,
+    };
+    const complete = items.length > 0 && items.every(item => item.status === 'installed' || item.status === 'installed-now');
+    const postCheckSummary = {
+        total: postChecks.length,
+        passed: postChecks.filter(item => item.status === 'passed').length,
+        warned: postChecks.filter(item => item.status === 'warn').length,
+        failed: postChecks.filter(item => item.status === 'failed').length,
+    };
+    const recommendations = [];
+    const postCheckCommands = buildPostCheckCommands(packIds, items);
+    const rollbackHints = buildRollbackHints(items);
+    if (!apply && summary.ready > 0)
+        recommendations.push('Re-run with --apply to install all ready dependencies in one pass.');
+    if (runtimeChecks.some(check => check.status === 'missing'))
+        recommendations.push('Install missing runtime dependencies before running --apply.');
+    if (runtimeChecks.some(check => check.status === 'warn'))
+        recommendations.push('Review runtime warnings; some tools may install but fail initialization or post-checks.');
+    if (summary.manualReview > 0)
+        recommendations.push('Review manual-review items for missing package managers, PATH setup, or platform-specific configuration.');
+    if (summary.needsInit > 0)
+        recommendations.push('Run the listed initialization commands before treating installed CLIs as ready for autonomous use.');
+    if (summary.versionDrift > 0)
+        recommendations.push('Resolve version-drift items before relying on their generated skills, hooks, or artifacts.');
+    if (items.some(item => item.id === 'frontend-design'))
+        recommendations.push('frontend-design is optional; keep it as an explicit companion only when implementation ideation is needed.');
+    if (items.some(item => item.id === 'awesome-design-md'))
+        recommendations.push('Use awesome-design-md as the source of DESIGN.md, brand direction, and visual-language selection.');
+    if (items.some(item => item.id === 'ui-ux-pro-max'))
+        recommendations.push('Use ui-ux-pro-max for UX flow, UI state, accessibility, and responsive acceptance checks.');
+    if (items.some(item => item.id === 'gbrain'))
+        recommendations.push('After GBrain is installed, validate remote or thin-client health with `scale memory provider status --json`.');
+    if (items.some(item => item.id === 'graphify' || item.id === 'codegraph'))
+        recommendations.push('After knowledge tools are installed, run `scale codegraph status --json` and initialize the project index or graph artifacts as needed.');
+    if (postCheckSummary.failed > 0)
+        recommendations.push('Resolve failed post-checks before treating the dependency bootstrap as production-ready.');
+    if (postCheckSummary.warned > 0)
+        recommendations.push('Review warned post-checks; they usually indicate provider initialization or project index/artifact setup is still pending.');
+    return {
+        ok: summary.failed === 0 && postCheckSummary.failed === 0,
+        complete,
+        projectDir,
+        scaleDir,
+        packIds,
+        includeIds,
+        apply,
+        runtimeChecks,
+        items,
+        summary,
+        postActions,
+        postChecks,
+        postCheckSummary,
+        postCheckCommands,
+        rollbackHints,
+        recommendations,
+    };
+}
+function buildRuntimeChecks(items) {
+    const ids = new Set(items.map(item => item.id));
+    const requirements = new Map();
+    const requireRuntime = (runtimeId, requiredFor) => {
+        const existing = requirements.get(runtimeId) ?? new Set();
+        for (const value of requiredFor)
+            existing.add(value);
+        requirements.set(runtimeId, existing);
+    };
+    const uiIds = ['awesome-design-md', 'ui-ux-pro-max', 'frontend-design'].filter(id => ids.has(id));
+    if (uiIds.length > 0) {
+        requireRuntime('node', uiIds);
+        requireRuntime('npx', uiIds);
+    }
+    if (ids.has('rtk'))
+        requireRuntime('cargo', ['rtk']);
+    if (ids.has('gbrain'))
+        requireRuntime('bun', ['gbrain']);
+    if (ids.has('graphify')) {
+        requireRuntime('python', ['graphify']);
+        requireRuntime('python-installer', ['graphify']);
+    }
+    if (ids.has('codegraph')) {
+        requireRuntime('node', ['codegraph']);
+        requireRuntime('npm', ['codegraph']);
+    }
+    const checks = [];
+    const requiredFor = (runtimeId) => [...(requirements.get(runtimeId) ?? [])];
+    if (requirements.has('node'))
+        checks.push(nodeRuntimeCheck(requiredFor('node')));
+    if (requirements.has('npx'))
+        checks.push(commandRuntimeCheck({
+            id: 'npx',
+            label: 'npx',
+            candidates: [{ command: 'npx', args: ['--version'], display: 'npx' }],
+            requiredFor: requiredFor('npx'),
+            installHint: 'Install Node.js 20+; npm/npx are bundled with the official Node.js installer.',
+        }));
+    if (requirements.has('npm'))
+        checks.push(commandRuntimeCheck({
+            id: 'npm',
+            label: 'npm',
+            candidates: [{ command: 'npm', args: ['--version'], display: 'npm' }],
+            requiredFor: requiredFor('npm'),
+            installHint: 'Install Node.js 20+; npm is bundled with the official Node.js installer.',
+        }));
+    if (requirements.has('cargo'))
+        checks.push(commandRuntimeCheck({
+            id: 'cargo',
+            label: 'Rust/Cargo',
+            candidates: [{ command: 'cargo', args: ['--version'], display: 'cargo' }],
+            requiredFor: requiredFor('cargo'),
+            installHint: 'Install Rust with rustup, then re-open the shell so cargo is on PATH.',
+        }));
+    if (requirements.has('bun'))
+        checks.push(commandRuntimeCheck({
+            id: 'bun',
+            label: 'Bun',
+            candidates: [{ command: 'bun', args: ['--version'], display: 'bun' }],
+            requiredFor: requiredFor('bun'),
+            installHint: 'Install Bun from https://bun.sh and re-open the shell so bun is on PATH.',
+        }));
+    if (requirements.has('python'))
+        checks.push(pythonRuntimeCheck(requiredFor('python')));
+    if (requirements.has('python-installer'))
+        checks.push(pythonInstallerRuntimeCheck(requiredFor('python-installer')));
+    return checks;
+}
+function commandRuntimeCheck(input) {
+    const detected = firstAvailableRuntimeTool(input.candidates);
+    if (!detected) {
+        return {
+            id: input.id,
+            label: input.label,
+            commands: input.candidates.map(candidate => candidate.display),
+            status: 'missing',
+            requiredFor: input.requiredFor,
+            reason: `${input.label} was not detected on PATH.`,
+            installHint: input.installHint,
+        };
+    }
+    return {
+        id: input.id,
+        label: input.label,
+        commands: input.candidates.map(candidate => candidate.display),
+        status: 'ok',
+        requiredFor: input.requiredFor,
+        detectedCommand: detected.display,
+        version: firstLine(detected.output),
+        reason: `${input.label} is available via ${detected.display}.`,
+        installHint: input.installHint,
+    };
+}
+function nodeRuntimeCheck(requiredFor) {
+    const detected = firstAvailableRuntimeTool([{ command: 'node', args: ['--version'], display: 'node' }]);
+    const commands = ['node'];
+    const installHint = 'Install Node.js 20+ from https://nodejs.org.';
+    if (!detected) {
+        return {
+            id: 'node',
+            label: 'Node.js',
+            commands,
+            status: 'missing',
+            requiredFor,
+            reason: 'Node.js was not detected on PATH.',
+            installHint,
+        };
+    }
+    const version = firstLine(detected.output);
+    const parsed = parseSemver(version);
+    if (parsed && parsed.major < 20) {
+        return {
+            id: 'node',
+            label: 'Node.js',
+            commands,
+            status: 'warn',
+            requiredFor,
+            detectedCommand: detected.display,
+            version,
+            reason: `Node.js ${version} is installed, but SCALE setup expects Node.js 20+ for current third-party installers.`,
+            installHint,
+        };
+    }
+    return {
+        id: 'node',
+        label: 'Node.js',
+        commands,
+        status: 'ok',
+        requiredFor,
+        detectedCommand: detected.display,
+        version,
+        reason: `Node.js ${version} is available.`,
+        installHint,
+    };
+}
+function pythonRuntimeCheck(requiredFor) {
+    const candidates = [
+        { command: 'python', args: ['--version'], display: 'python' },
+        { command: 'python3', args: ['--version'], display: 'python3' },
+        { command: 'py', args: ['--version'], display: 'py' },
+    ];
+    const detected = firstAvailableRuntimeTool(candidates);
+    const installHint = 'Install Python 3.10+ and prefer uv or pipx for graphify installation.';
+    if (!detected) {
+        return {
+            id: 'python',
+            label: 'Python',
+            commands: candidates.map(candidate => candidate.display),
+            status: 'missing',
+            requiredFor,
+            reason: 'Python 3.10+ was not detected on PATH.',
+            installHint,
+        };
+    }
+    const version = firstLine(detected.output);
+    const parsed = parseSemver(version);
+    if (!parsed || parsed.major < 3 || (parsed.major === 3 && parsed.minor < 10)) {
+        return {
+            id: 'python',
+            label: 'Python',
+            commands: candidates.map(candidate => candidate.display),
+            status: 'warn',
+            requiredFor,
+            detectedCommand: detected.display,
+            version,
+            reason: `${version} is detected, but Graphify requires Python 3.10+.`,
+            installHint,
+        };
+    }
+    return {
+        id: 'python',
+        label: 'Python',
+        commands: candidates.map(candidate => candidate.display),
+        status: 'ok',
+        requiredFor,
+        detectedCommand: detected.display,
+        version,
+        reason: `${version} is available for Graphify.`,
+        installHint,
+    };
+}
+function pythonInstallerRuntimeCheck(requiredFor) {
+    const candidates = [
+        { command: 'uv', args: ['--version'], display: 'uv' },
+        { command: 'pipx', args: ['--version'], display: 'pipx' },
+        { command: 'pip', args: ['--version'], display: 'pip' },
+        { command: 'pip3', args: ['--version'], display: 'pip3' },
+        { command: 'python', args: ['-m', 'pip', '--version'], display: 'python -m pip' },
+        { command: 'python3', args: ['-m', 'pip', '--version'], display: 'python3 -m pip' },
+    ];
+    const detected = firstAvailableRuntimeTool(candidates);
+    const installHint = 'Install uv or pipx first; pip is supported only as a fallback for graphify.';
+    if (!detected) {
+        return {
+            id: 'python-installer',
+            label: 'Python installer',
+            commands: candidates.map(candidate => candidate.display),
+            status: 'missing',
+            requiredFor,
+            reason: 'No supported Python installer was detected for graphify.',
+            installHint,
+        };
+    }
+    const version = firstLine(detected.output);
+    const preferred = detected.display === 'uv' || detected.display === 'pipx';
+    return {
+        id: 'python-installer',
+        label: 'Python installer',
+        commands: candidates.map(candidate => candidate.display),
+        status: preferred ? 'ok' : 'warn',
+        requiredFor,
+        detectedCommand: detected.display,
+        version,
+        reason: preferred
+            ? `${detected.display} is available for isolated graphify installation.`
+            : `${detected.display} is available, but uv or pipx is preferred to avoid polluting project environments.`,
+        installHint,
+    };
+}
+function firstAvailableRuntimeTool(candidates) {
+    for (const candidate of candidates) {
+        const result = runHealthCommand(candidate.command, candidate.args);
+        if (!result.ok)
+            continue;
+        return {
+            display: candidate.display,
+            output: `${result.stdout}\n${result.stderr}`.trim(),
+        };
+    }
+    return undefined;
+}
+function parseSemver(value) {
+    const match = value.match(/(\d+)\.(\d+)(?:\.(\d+))?/);
+    if (!match)
+        return null;
+    return {
+        major: Number.parseInt(match[1], 10),
+        minor: Number.parseInt(match[2], 10),
+        patch: Number.parseInt(match[3] ?? '0', 10),
+    };
+}
+export function runDependencyBootstrapPostChecks(input, deps = {}) {
+    const inspectTools = deps.inspectTools ?? inspectToolCapabilities;
+    const inspectMemory = deps.inspectMemory ?? inspectMemoryProviders;
+    const inspectCode = deps.inspectCode ?? inspectCodeIntelligence;
+    const toolIds = unique(input.items.map(item => item.id).filter(id => ['awesome-design-md', 'ui-ux-pro-max', 'frontend-design', 'rtk', 'gbrain', 'codegraph', 'graphify'].includes(id)));
+    const results = [];
+    if (toolIds.length > 0) {
+        const toolReport = inspectTools({
+            projectDir: input.projectDir,
+            homeDir: input.homeDir,
+            toolIds,
+        });
+        const missing = toolReport.tools.filter(tool => !tool.installed).map(tool => tool.id);
+        results.push({
+            id: 'tool-capabilities',
+            label: 'Tool Doctor',
+            command: `scale tool doctor --tools ${toolIds.join(',')} --json`,
+            status: toolReport.ok ? 'passed' : 'failed',
+            summary: `${toolReport.summary.installed}/${toolReport.summary.total} selected tools are available${missing.length > 0 ? `; missing: ${missing.join(', ')}` : ''}`,
+            details: {
+                toolIds,
+                missing,
+            },
+        });
+    }
+    if (input.items.some(item => item.id === 'gbrain')) {
+        const memoryReport = inspectMemory({ projectDir: input.projectDir, scaleDir: input.scaleDir });
+        const gbrain = memoryReport.providers.find(provider => provider.id === 'gbrain');
+        const warnings = [...memoryReport.warnings];
+        const status = !gbrain?.available ? 'failed' : warnings.length > 0 ? 'warn' : 'passed';
+        results.push({
+            id: 'memory-provider',
+            label: 'Memory Provider',
+            command: 'scale memory provider status --json',
+            status,
+            summary: gbrain
+                ? `mode=${memoryReport.routing.mode}; order=${memoryReport.routing.defaultOrder.join(' -> ')}; gbrain=${gbrain.available ? 'available' : 'unavailable'}`
+                : 'gbrain provider entry is missing from routing policy',
+            details: {
+                warnings,
+                gbrainReason: gbrain?.reason,
+            },
+        });
+    }
+    if (input.items.some(item => item.id === 'codegraph' || item.id === 'graphify')) {
+        const codeReport = inspectCode({ projectDir: input.projectDir, scaleDir: input.scaleDir });
+        const codegraph = codeReport.providers.find(provider => provider.id === 'codegraph');
+        const graphify = codeReport.providers.find(provider => provider.id === 'graphify');
+        const warnings = [];
+        let failed = false;
+        if (input.items.some(item => item.id === 'codegraph')) {
+            if (!codegraph?.available)
+                failed = true;
+            else if (!codeReport.projectIndexExists)
+                warnings.push('codegraph CLI is installed but the project index (.codegraph/) is not initialized yet');
+        }
+        if (input.items.some(item => item.id === 'graphify') && !graphify?.available) {
+            warnings.push('graphify CLI is installed but graphify-out/graph.json is not present yet');
+        }
+        results.push({
+            id: 'code-intelligence',
+            label: 'Code Intelligence',
+            command: 'scale codegraph status --json',
+            status: failed ? 'failed' : warnings.length > 0 ? 'warn' : 'passed',
+            summary: [
+                codegraph ? `codegraph=${codegraph.available ? 'available' : 'missing'}` : undefined,
+                graphify ? `graphify-artifact=${graphify.available ? 'available' : 'missing'}` : undefined,
+                `projectIndex=${codeReport.projectIndexExists ? 'present' : 'missing'}`,
+            ].filter(Boolean).join('; '),
+            details: {
+                warnings,
+            },
+        });
+    }
+    return results;
+}
+function inspectDefinition(definition, context) {
+    const detectedBy = detectDefinition(definition, context.projectDir, context.homeDir);
+    const installed = detectedBy !== 'missing';
+    const prerequisites = definition.prerequisites.map(requirement => ({
+        command: requirement,
+        present: requirementSatisfied(requirement, context.commandExists),
+    }));
+    const health = installed && definition.healthCheck ? definition.healthCheck(context) : undefined;
+    const installCommand = installed ? undefined : definition.installCommand(context) ?? undefined;
+    const installSupported = Boolean(installCommand);
+    return {
+        id: definition.id,
+        name: definition.name,
+        kind: definition.kind,
+        packs: definition.packs,
+        source: definition.source,
+        installed,
+        status: installed
+            ? health?.bootstrapStatus ?? 'installed'
+            : installSupported ? 'ready' : 'manual-review',
+        installCommand,
+        installSupported,
+        detectedBy,
+        prerequisites,
+        manualReason: installed ? undefined : definition.manualReason,
+        health,
+    };
+}
+function detectDefinition(definition, projectDir, homeDir) {
+    const context = { projectDir, homeDir, commandExists: externalCommandExists };
+    const detectedPath = definition.detectPaths?.(context).find(candidate => existsSync(candidate));
+    if (detectedPath)
+        return detectedPath;
+    if (definition.detectSkillId) {
+        const path = skillCandidatePaths(projectDir, homeDir, definition.detectSkillId).find(candidate => existsSync(candidate));
+        return path ?? 'missing';
+    }
+    if (definition.detectCommand && externalCommandExists(definition.detectCommand))
+        return `PATH:${definition.detectCommand}`;
+    return 'missing';
+}
+function skillCandidatePaths(projectDir, homeDir, skillId) {
+    return [
+        join(projectDir, '.agents', 'skills', skillId, 'SKILL.md'),
+        join(projectDir, '.codex', 'skills', skillId, 'SKILL.md'),
+        join(projectDir, '.claude', 'skills', skillId, 'SKILL.md'),
+        join(homeDir, '.agents', 'skills', skillId, 'SKILL.md'),
+        join(homeDir, '.codex', 'skills', skillId, 'SKILL.md'),
+        join(homeDir, '.claude', 'skills', skillId, 'SKILL.md'),
+    ];
+}
+function requirementSatisfied(requirement, commandExists) {
+    return requirement.split('|').some(command => commandExists(command));
+}
+function buildGraphifyInstallCommand(context) {
+    if (context.commandExists('uv'))
+        return GRAPHIFY_UV_INSTALL;
+    if (context.commandExists('pipx'))
+        return GRAPHIFY_PIPX_INSTALL;
+    if (context.commandExists('pip'))
+        return GRAPHIFY_PIP_INSTALL;
+    if (context.commandExists('pip3'))
+        return GRAPHIFY_PIP3_INSTALL;
+    if (context.commandExists('python'))
+        return GRAPHIFY_PYTHON_INSTALL;
+    if (context.commandExists('python3'))
+        return GRAPHIFY_PYTHON3_INSTALL;
+    return null;
+}
+function buildGbrainInstallCommand(context) {
+    if (!context.commandExists('bun'))
+        return null;
+    return GBRAIN_INSTALL;
+}
+function checkRtkHealth() {
+    const gain = runHealthCommand('rtk', ['gain']);
+    if (!gain.ok) {
+        return {
+            status: 'warn',
+            bootstrapStatus: 'needs-init',
+            reason: 'rtk CLI is installed but `rtk gain` did not run successfully; token-savings evidence is not available yet.',
+            nextCommands: ['rtk init -g --codex', 'rtk gain'],
+        };
+    }
+    const output = `${gain.stdout}\n${gain.stderr}`;
+    if (/no hook installed/i.test(output)) {
+        return {
+            status: 'warn',
+            bootstrapStatus: 'needs-init',
+            reason: 'rtk CLI is installed, but the shell hook is not installed so command-output compression is not automatic yet.',
+            nextCommands: ['rtk init -g --codex', 'rtk gain'],
+        };
+    }
+    return { status: 'ok', reason: 'rtk CLI and gain evidence are available.' };
+}
+function checkGbrainHealth() {
+    const doctor = runHealthCommand('gbrain', ['doctor', '--json'], 10_000);
+    if (doctor.ok)
+        return { status: 'ok', reason: 'gbrain doctor passed; provider can be used for default memory routing.' };
+    const output = `${doctor.stdout}\n${doctor.stderr}`;
+    return {
+        status: 'warn',
+        bootstrapStatus: 'needs-init',
+        reason: /no brain configured/i.test(output)
+            ? 'gbrain CLI is installed but no brain is configured yet; cross-session recall will fail until initialized.'
+            : `gbrain CLI is installed but doctor failed: ${firstLine(output)}`,
+        nextCommands: ['gbrain init --pglite', 'gbrain doctor --json', 'scale memory provider status --json'],
+    };
+}
+function checkGraphifyHealth() {
+    const version = runHealthCommand('graphify', ['--version']);
+    const hook = runHealthCommand('graphify', ['hook', 'status'], 10_000);
+    const output = `${version.stdout}\n${version.stderr}\n${hook.stdout}\n${hook.stderr}`;
+    if (/skill.*version|package.*version|drift|outdated/i.test(output)) {
+        return {
+            status: 'warn',
+            bootstrapStatus: 'version-drift',
+            reason: 'graphify CLI is installed but its generated skill/hook assets appear out of sync with the package.',
+            nextCommands: ['graphify install --platform codex', 'graphify hook status', 'scale codegraph status --json'],
+        };
+    }
+    if (!hook.ok || /not installed|missing/i.test(output)) {
+        return {
+            status: 'warn',
+            bootstrapStatus: 'needs-init',
+            reason: 'graphify CLI is installed but Codex hooks are not fully configured.',
+            nextCommands: ['graphify install --platform codex', 'graphify hook status'],
+        };
+    }
+    return { status: 'ok', reason: 'graphify CLI and hook status are available.' };
+}
+function checkCodeGraphHealth(context) {
+    const indexPath = join(context.projectDir, '.codegraph');
+    if (!existsSync(indexPath)) {
+        return {
+            status: 'warn',
+            bootstrapStatus: 'needs-init',
+            reason: 'codegraph CLI is installed but this project has no .codegraph index yet.',
+            nextCommands: ['codegraph init -i', 'scale codegraph status --json'],
+        };
+    }
+    const status = runHealthCommand('codegraph', ['status', context.projectDir], 10_000);
+    if (!status.ok) {
+        return {
+            status: 'warn',
+            bootstrapStatus: 'needs-init',
+            reason: `codegraph index exists but status check failed: ${firstLine(`${status.stdout}\n${status.stderr}`)}`,
+            nextCommands: ['codegraph init -i', 'codegraph status .'],
+        };
+    }
+    return { status: 'ok', reason: 'codegraph CLI and project index are available.' };
+}
+function runHealthCommand(command, args, timeout = 5_000) {
+    try {
+        const result = execaSync(command, args, {
+            reject: false,
+            timeout,
+        });
+        return {
+            ok: (result.exitCode ?? 1) === 0,
+            stdout: result.stdout ?? '',
+            stderr: result.stderr ?? '',
+        };
+    }
+    catch (error) {
+        const err = error;
+        return {
+            ok: false,
+            stdout: String(err.stdout ?? ''),
+            stderr: String(err.stderr ?? err.message ?? ''),
+        };
+    }
+}
+function firstLine(value) {
+    return value.split(/\r?\n/).map(line => line.trim()).find(Boolean) ?? 'unknown error';
+}
+function quotePath(path) {
+    return `"${path.replace(/"/g, '\\"')}"`;
+}
+async function runInstallCommand(shellCommand) {
+    const wrapped = wrapShellCommandWithRtk(shellCommand);
+    const result = wrapped
+        ? await execa(wrapped.command, wrapped.args, { reject: false, timeout: 300_000, all: false })
+        : await execa(shellCommand, { shell: true, reject: false, timeout: 300_000, all: false });
+    return {
+        ok: (result.exitCode ?? 1) === 0,
+        output: result.stdout ?? '',
+        error: result.stderr ?? '',
+    };
+}
+export function applyDependencyBootstrapPostActions(projectDir, scaleDir, items, deps = {}) {
+    const writeMemoryConfig = deps.writeMemoryConfig ?? writeMemoryProvidersConfig;
+    const switchMemoryProvider = deps.switchMemoryProvider ?? useMemoryProvider;
+    const writeCodeConfig = deps.writeCodeConfig ?? writeCodeIntelligenceConfig;
+    const ids = new Set(items.map(item => item.id));
+    const actions = [];
+    if (ids.has('gbrain')) {
+        const memoryConfig = writeMemoryConfig({ projectDir, scaleDir });
+        actions.push(`${memoryConfig.written ? 'Wrote' : 'Reused'} ${memoryConfig.path}`);
+        const provider = switchMemoryProvider({ projectDir, scaleDir, provider: 'gbrain' });
+        const previousOrder = provider.previousOrder.join(' -> ');
+        const nextOrder = provider.nextOrder.join(' -> ');
+        actions.push(previousOrder === nextOrder
+            ? `Memory provider order unchanged: ${nextOrder}`
+            : `Memory provider order: ${previousOrder} => ${nextOrder}`);
+    }
+    if (ids.has('graphify') || ids.has('codegraph')) {
+        const codeIntelligence = writeCodeConfig({ projectDir, scaleDir });
+        actions.push(`${codeIntelligence.written ? 'Wrote' : 'Reused'} ${codeIntelligence.path}`);
+    }
+    return actions;
+}
+function selectDefinitions(packIds, includeIds) {
+    const selectedPacks = new Set(packIds.includes('full') ? ['ui', 'memory', 'knowledge', 'external-cli'] : packIds);
+    const selectedIds = new Set(includeIds);
+    return DEPENDENCY_BOOTSTRAP_DEFINITIONS.filter(definition => definition.packs.some(pack => selectedPacks.has(pack)) || selectedIds.has(definition.id));
+}
+function buildPostCheckCommands(packIds, items) {
+    const commands = new Set();
+    const selectedPacks = new Set(packIds.includes('full') ? ['ui', 'memory', 'knowledge', 'external-cli'] : packIds);
+    const ids = new Set(items.map(item => item.id));
+    if (selectedPacks.has('ui')) {
+        const uiToolIds = items
+            .filter(item => item.kind === 'skill' && item.packs.includes('ui'))
+            .map(item => item.id);
+        if (uiToolIds.length > 0)
+            commands.add(`scale tool doctor --tools ${uiToolIds.join(',')} --json`);
+        commands.add('scale skill doctor --json');
+    }
+    if (selectedPacks.has('memory') || ids.has('gbrain')) {
+        commands.add('scale memory provider status --json');
+    }
+    if (selectedPacks.has('knowledge') || ids.has('codegraph') || ids.has('graphify')) {
+        commands.add('scale tool doctor --tools codegraph,graphify --json');
+        commands.add('scale codegraph status --json');
+    }
+    if (selectedPacks.has('external-cli') || ids.has('rtk')) {
+        commands.add('scale tool doctor --tools rtk --json');
+    }
+    commands.add('scale doctor');
+    return [...commands];
+}
+function buildRollbackHints(items) {
+    const hints = new Set();
+    for (const item of items) {
+        switch (item.id) {
+            case 'rtk':
+                hints.add('RTK rollback: cargo uninstall rtk');
+                break;
+            case 'codegraph':
+                hints.add('CodeGraph rollback: npm uninstall -g @colbymchenry/codegraph');
+                break;
+            case 'graphify':
+                hints.add('Graphify rollback: pip uninstall graphify  # or pip3/python -m pip uninstall graphify');
+                break;
+            case 'gbrain':
+                hints.add('GBrain rollback: bun unlink gbrain, then remove ~/.scale/vendor/gbrain if you want a full local cleanup');
+                break;
+            case 'awesome-design-md':
+            case 'ui-ux-pro-max':
+            case 'frontend-design':
+                hints.add(`Skill rollback (${item.id}): remove the installed skill directory under ~/.agents/skills/${item.id} after review`);
+                break;
+            default:
+                break;
+        }
+    }
+    return [...hints];
+}
+function normalizePackIds(input) {
+    const requested = unique((input ?? ['full']).map(value => value.trim()).filter(Boolean));
+    const packIds = requested
+        .flatMap(value => value.split(','))
+        .map(value => value.trim())
+        .filter(Boolean)
+        .map(value => normalizePackId(value))
+        .filter((value) => value !== null);
+    return packIds.length > 0 ? unique(packIds) : ['full'];
+}
+function normalizePackId(value) {
+    if (value === 'ui' || value === 'memory' || value === 'knowledge' || value === 'external-cli' || value === 'full')
+        return value;
+    if (value === 'external' || value === 'cli')
+        return 'external-cli';
+    return null;
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function resolveScaleRoot(projectDir, scaleDir) {
+    const candidate = scaleDir ?? '.scale';
+    return resolve(projectDir, candidate);
+}
+//# sourceMappingURL=DependencyBootstrap.js.map