@open-agent-toolkit/cli 0.0.34 → 0.0.36

package/dist/commands/init/tools/index.js

@@ -1,3 +1,4 @@
+import { rm, unlink } from 'node:fs/promises';
 import { join } from 'node:path';
 import { buildCommandContext, } from '../../../app/command-context.js';
 import { copyDirWithStatus } from '../../init/tools/shared/copy-helpers.js';
@@ -6,6 +7,8 @@ import { addLocalPaths } from '../../local/manage.js';
 import { removeAgentsMdSection, upsertAgentsMdSection, } from '../../shared/agents-md.js';
 import { selectManyWithAbort, selectWithAbort, } from '../../shared/shared.prompts.js';
 import { readGlobalOptions } from '../../shared/shared.utils.js';
+import { canonicalPathsForPacks, setInstalledCanonicalPaths, } from '../../tools/shared/install-sync-context.js';
+import { scanTools } from '../../tools/shared/scan-tools.js';
 import { readOatConfig, resolveLocalPaths, writeOatConfig, } from '../../../config/oat-config.js';
 import { resolveAssetsRoot } from '../../../fs/assets.js';
 import { resolveProjectRoot, resolveScopeRoot } from '../../../fs/paths.js';
@@ -13,38 +16,56 @@ import { Command } from 'commander';
 import { createInitToolsCoreCommand } from './core/index.js';
 import { installCore as defaultInstallCore, } from './core/install-core.js';
 import { createInitToolsDocsCommand } from './docs/index.js';
-import { DOCS_SKILLS, installDocs as defaultInstallDocs, } from './docs/install-docs.js';
+import { installDocs as defaultInstallDocs, } from './docs/install-docs.js';
 import { createInitToolsIdeasCommand } from './ideas/index.js';
 import { installIdeas as defaultInstallIdeas, } from './ideas/install-ideas.js';
+import { buildPackInstallStateMap, } from './install-state.js';
 import { createInitToolsProjectManagementCommand } from './project-management/index.js';
 import { installProjectManagement as defaultInstallProjectManagement, } from './project-management/install-project-management.js';
 import { createInitToolsResearchCommand } from './research/index.js';
-import { installResearch as defaultInstallResearch, RESEARCH_SKILLS, } from './research/install-research.js';
+import { installResearch as defaultInstallResearch, } from './research/install-research.js';
+import { DOCS_SKILLS, IDEA_SKILLS, RESEARCH_AGENTS, RESEARCH_SKILLS, UTILITY_SKILLS, } from './shared/skill-manifest.js';
 import { createInitToolsUtilityCommand } from './utility/index.js';
-import { installUtility as defaultInstallUtility, UTILITY_SKILLS, } from './utility/install-utility.js';
+import { installUtility as defaultInstallUtility, } from './utility/install-utility.js';
 import { createInitToolsWorkflowsCommand } from './workflows/index.js';
 import { installWorkflows as defaultInstallWorkflows, } from './workflows/install-workflows.js';
 function formatVersionForDisplay(version) {
     return version ?? '(unversioned)';
 }
-const PACK_CHOICES = [
-    { label: 'Core [user]', value: 'core', checked: true },
-    { label: 'Ideas [project|user]', value: 'ideas', checked: true },
-    { label: 'Docs [project|user]', value: 'docs', checked: true },
-    {
-        label: 'Project Management [project]',
-        value: 'project-management',
-        checked: false,
-    },
-    { label: 'Workflows [project]', value: 'workflows', checked: true },
-    { label: 'Utility [project|user]', value: 'utility', checked: true },
-    { label: 'Research [project|user]', value: 'research', checked: true },
+const ALL_TOOL_PACKS = [
+    'core',
+    'ideas',
+    'docs',
+    'workflows',
+    'utility',
+    'project-management',
+    'research',
 ];
+const USER_ELIGIBLE_PACK_MEMBERS = {
+    ideas: {
+        skills: IDEA_SKILLS,
+        agents: [],
+    },
+    docs: {
+        skills: DOCS_SKILLS,
+        agents: [],
+    },
+    utility: {
+        skills: UTILITY_SKILLS,
+        agents: [],
+    },
+    research: {
+        skills: RESEARCH_SKILLS,
+        agents: RESEARCH_AGENTS,
+    },
+};
+let lastRunInitToolsMetadata = null;
 const DEFAULT_DEPENDENCIES = {
     buildCommandContext,
     resolveProjectRoot,
     resolveScopeRoot,
     resolveAssetsRoot,
+    scanTools,
     selectManyWithAbort,
     selectWithAbort,
     installCore: defaultInstallCore,
@@ -55,6 +76,21 @@ const DEFAULT_DEPENDENCIES = {
     installProjectManagement: defaultInstallProjectManagement,
     installResearch: defaultInstallResearch,
     copyDirWithStatus,
+    removeDirectory: async (target) => {
+        await rm(target, { recursive: true, force: true });
+    },
+    removeFile: async (target) => {
+        try {
+            await unlink(target);
+        }
+        catch (error) {
+            if (!(error instanceof Error) ||
+                !('code' in error) ||
+                error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+    },
     addLocalPaths,
     applyGitignore,
     readOatConfig,
@@ -69,7 +105,120 @@ const USER_ELIGIBLE_PACKS = new Set([
     'utility',
     'research',
 ]);
-async function resolvePackScopes(context, selections, dependencies) {
+function isUserEligiblePack(pack) {
+    return USER_ELIGIBLE_PACKS.has(pack);
+}
+async function loadInstalledPackStates(projectRoot, userRoot, assetsRoot, dependencies) {
+    const [projectTools, userTools] = await Promise.all([
+        dependencies.scanTools({
+            scope: 'project',
+            scopeRoot: projectRoot,
+            assetsRoot,
+        }),
+        dependencies.scanTools({
+            scope: 'user',
+            scopeRoot: userRoot,
+            assetsRoot,
+        }),
+    ]);
+    return buildPackInstallStateMap(ALL_TOOL_PACKS, [
+        ...projectTools,
+        ...userTools,
+    ]);
+}
+function formatInstalledLocation(location) {
+    switch (location) {
+        case 'project':
+            return 'project';
+        case 'user':
+            return 'user';
+        case 'both':
+            return 'project + user';
+        default:
+            return 'not installed';
+    }
+}
+function buildPackChoices(installedPackStates) {
+    return [
+        {
+            label: `Core [user]${installedPackStates.core.location === 'not-installed' ? '' : ` (installed: ${formatInstalledLocation(installedPackStates.core.location)})`}`,
+            value: 'core',
+            checked: true,
+        },
+        {
+            label: `Ideas [project|user]${installedPackStates.ideas.location === 'not-installed' ? '' : ` (installed: ${formatInstalledLocation(installedPackStates.ideas.location)})`}`,
+            value: 'ideas',
+            checked: true,
+        },
+        {
+            label: `Docs [project|user]${installedPackStates.docs.location === 'not-installed' ? '' : ` (installed: ${formatInstalledLocation(installedPackStates.docs.location)})`}`,
+            value: 'docs',
+            checked: true,
+        },
+        {
+            label: `Project Management [project]${installedPackStates['project-management'].location === 'not-installed' ? '' : ` (installed: ${formatInstalledLocation(installedPackStates['project-management'].location)})`}`,
+            value: 'project-management',
+            checked: false,
+        },
+        {
+            label: `Workflows [project]${installedPackStates.workflows.location === 'not-installed' ? '' : ` (installed: ${formatInstalledLocation(installedPackStates.workflows.location)})`}`,
+            value: 'workflows',
+            checked: true,
+        },
+        {
+            label: `Utility [project|user]${installedPackStates.utility.location === 'not-installed' ? '' : ` (installed: ${formatInstalledLocation(installedPackStates.utility.location)})`}`,
+            value: 'utility',
+            checked: true,
+        },
+        {
+            label: `Research [project|user]${installedPackStates.research.location === 'not-installed' ? '' : ` (installed: ${formatInstalledLocation(installedPackStates.research.location)})`}`,
+            value: 'research',
+            checked: true,
+        },
+    ];
+}
+function buildUserScopeChoices(packs, installedPackStates) {
+    return packs.map((pack) => {
+        const location = installedPackStates[pack].location;
+        return {
+            label: location === 'not-installed'
+                ? pack
+                : `${pack} (current: ${formatInstalledLocation(location)})`,
+            value: pack,
+            checked: location === 'user' || location === 'both',
+        };
+    });
+}
+async function resolveBothScopeTarget(pack, dependencies, interactive) {
+    const selection = await dependencies.selectWithAbort(`${pack} is currently installed in project and user scope. Keep both installs or normalize to user scope?`, [
+        {
+            label: 'Keep project + user (recommended)',
+            value: 'both',
+            description: 'Preserve both installed copies',
+        },
+        {
+            label: 'User only',
+            value: 'user',
+            description: 'Remove the project-scoped copy',
+        },
+    ], { interactive });
+    return selection ?? 'both';
+}
+export function consumeInitToolsRunMetadata() {
+    const metadata = lastRunInitToolsMetadata;
+    lastRunInitToolsMetadata = null;
+    return metadata;
+}
+async function removePackFromScope(pack, root, dependencies) {
+    const members = USER_ELIGIBLE_PACK_MEMBERS[pack];
+    for (const skill of members.skills) {
+        await dependencies.removeDirectory(join(root, '.agents', 'skills', skill));
+    }
+    for (const agent of members.agents) {
+        await dependencies.removeFile(join(root, '.agents', 'agents', agent));
+    }
+}
+async function resolvePackScopes(context, selections, installedPackStates, dependencies) {
     const scopes = {};
     // Workflows is always project-only
     for (const pack of selections) {
@@ -81,7 +230,7 @@ async function resolvePackScopes(context, selections, dependencies) {
     if (selections.includes('core')) {
         scopes.core = 'user';
     }
-    const eligiblePacks = selections.filter((pack) => USER_ELIGIBLE_PACKS.has(pack));
+    const eligiblePacks = selections.filter((pack) => isUserEligiblePack(pack));
     if (eligiblePacks.length === 0) {
         return scopes;
     }
@@ -106,31 +255,45 @@ async function resolvePackScopes(context, selections, dependencies) {
         return scopes;
     }
     // Interactive: let user pick which packs go to user scope
-    const userScopePacks = (await dependencies.selectManyWithAbort('Which packs should install at user scope? (unselected go to project scope)', eligiblePacks.map((pack) => ({
-        label: pack,
-        value: pack,
-        checked: false,
-    })), { interactive: context.interactive })) ?? [];
+    const userScopePacks = (await dependencies.selectManyWithAbort('Which packs should install at user scope? (unselected go to project scope)', buildUserScopeChoices(eligiblePacks, installedPackStates), { interactive: context.interactive })) ?? [];
     const userScopeSet = new Set(userScopePacks);
     for (const pack of eligiblePacks) {
-        scopes[pack] = userScopeSet.has(pack) ? 'user' : 'project';
+        if (!userScopeSet.has(pack)) {
+            scopes[pack] = 'project';
+            continue;
+        }
+        scopes[pack] =
+            installedPackStates[pack].location === 'both'
+                ? await resolveBothScopeTarget(pack, dependencies, context.interactive)
+                : 'user';
     }
     return scopes;
 }
-function reportSuccess(context, selectedPacks, utilityScope) {
+function buildInstalledToolsConfig(selectedPacks, installedPackStates, existingTools) {
+    const selectedPackSet = new Set(selectedPacks);
+    const tools = { ...existingTools };
+    for (const pack of ALL_TOOL_PACKS) {
+        tools[pack] =
+            selectedPackSet.has(pack) ||
+                installedPackStates[pack].location !== 'not-installed';
+    }
+    return tools;
+}
+function reportSuccess(context, packs, syncScopes) {
     if (context.json) {
         context.logger.json({
             status: 'ok',
-            selectedPacks,
-            utilityScope,
+            installedPacks: packs,
+            syncScopes,
         });
         return;
     }
-    context.logger.info(`Installed tool packs: ${selectedPacks.join(', ')}`);
-    context.logger.info(`User-eligible pack scope: ${utilityScope}`);
-    context.logger.info('Run: oat sync --scope project');
-    if (utilityScope === 'user') {
-        context.logger.info('Also run: oat sync --scope user');
+    context.logger.info(`Installed tool packs: ${packs.map(({ pack, scope }) => `${pack} (${formatInstalledLocation(scope)})`).join(', ')}`);
+    syncScopes.forEach((scope, index) => {
+        context.logger.info(`${index === 0 ? 'Run' : 'Also run'}: oat sync --scope ${scope}`);
+    });
+    if (syncScopes.length === 0) {
+        context.logger.info('No sync needed.');
     }
 }
 function reportOutdatedSkills(context, outdatedSkills) {
@@ -139,7 +302,7 @@ function reportOutdatedSkills(context, outdatedSkills) {
     }
     context.logger.info('Outdated skills:');
     for (const skill of outdatedSkills) {
-        context.logger.info(`  ${skill.name}  ${formatVersionForDisplay(skill.installed)} -> ${formatVersionForDisplay(skill.bundled)}`);
+        context.logger.info(`  ${skill.name} (${skill.targetRoot})  ${formatVersionForDisplay(skill.installed)} -> ${formatVersionForDisplay(skill.bundled)}`);
     }
 }
 async function updateOutdatedSkills(outdatedSkills, assetsRoot, dependencies) {
@@ -162,7 +325,7 @@ const PACK_DESCRIPTIONS = {
     research: 'Research, analysis, verification, and synthesis',
 };
 export function buildToolPacksSectionBody(packs) {
-    const userPacks = packs.filter((p) => p.scope === 'user');
+    const userPacks = packs.filter((p) => p.scope === 'user' || p.scope === 'both');
     const hasWorkflows = packs.some((p) => p.pack === 'workflows');
     const lines = [
         '## Tool Packs',
@@ -178,7 +341,11 @@ export function buildToolPacksSectionBody(packs) {
     }
     lines.push('', '### Installed Packs', '');
     for (const { pack, scope } of packs) {
-        const suffix = scope === 'user' ? ' _(user scope)_' : '';
+        const suffix = scope === 'user'
+            ? ' _(user scope)_'
+            : scope === 'both'
+                ? ' _(project + user scope)_'
+                : '';
         lines.push(`- **${pack}** — ${PACK_DESCRIPTIONS[pack]}${suffix}`);
     }
     if (hasWorkflows) {
@@ -187,66 +354,118 @@ export function buildToolPacksSectionBody(packs) {
     return lines.join('\n');
 }
 export async function runInitTools(context, dependencies) {
+    lastRunInitToolsMetadata = null;
     try {
+        const projectRoot = await dependencies.resolveProjectRoot(context.cwd);
+        const userRoot = dependencies.resolveScopeRoot('user', context.cwd, context.home);
+        const assetsRoot = await dependencies.resolveAssetsRoot();
+        const initialPackStates = await loadInstalledPackStates(projectRoot, userRoot, assetsRoot, dependencies);
         const selectedPacks = context.interactive
-            ? ((await dependencies.selectManyWithAbort('Select tool packs to install', PACK_CHOICES, { interactive: context.interactive })) ?? [])
+            ? ((await dependencies.selectManyWithAbort('Select tool packs to install', buildPackChoices(initialPackStates), { interactive: context.interactive })) ?? [])
             : ['core', 'ideas', 'docs', 'workflows', 'utility', 'research'];
         if (!context.interactive) {
             selectedPacks.push('project-management');
         }
         if (selectedPacks.length === 0) {
+            lastRunInitToolsMetadata = { affectedScopes: [] };
             if (!context.json) {
                 context.logger.info('No tool packs selected.');
             }
             process.exitCode = 0;
             return [];
         }
-        const projectRoot = await dependencies.resolveProjectRoot(context.cwd);
-        const userRoot = dependencies.resolveScopeRoot('user', context.cwd, context.home);
-        const packScopes = await resolvePackScopes(context, selectedPacks, dependencies);
+        const packScopes = await resolvePackScopes(context, selectedPacks, initialPackStates, dependencies);
         function packRoot(pack) {
             return packScopes[pack] === 'user' ? userRoot : projectRoot;
         }
-        const assetsRoot = await dependencies.resolveAssetsRoot();
+        function packTargets(pack) {
+            return packScopes[pack] === 'both'
+                ? [projectRoot, userRoot]
+                : [packRoot(pack)];
+        }
         const outdatedSkills = [];
+        const affectedScopes = new Set();
+        for (const pack of selectedPacks) {
+            if (!isUserEligiblePack(pack)) {
+                continue;
+            }
+            const desiredScope = packScopes[pack];
+            const currentLocation = initialPackStates[pack].location;
+            if (desiredScope === 'both') {
+                continue;
+            }
+            if (desiredScope === 'user') {
+                if (currentLocation === 'project' || currentLocation === 'both') {
+                    await removePackFromScope(pack, projectRoot, dependencies);
+                    affectedScopes.add('project');
+                }
+                continue;
+            }
+            if (currentLocation === 'user' || currentLocation === 'both') {
+                await removePackFromScope(pack, userRoot, dependencies);
+                affectedScopes.add('user');
+            }
+        }
         if (selectedPacks.includes('core')) {
             // Core pack always installs at user scope, regardless of userEligibleScope
+            affectedScopes.add('user');
             const coreResult = await dependencies.installCore({
                 assetsRoot,
                 targetRoot: userRoot,
             });
             for (const skill of coreResult.outdatedSkills) {
-                outdatedSkills.push({ ...skill, targetRoot: userRoot });
+                outdatedSkills.push({
+                    ...skill,
+                    targetRoot: userRoot,
+                    selectionKey: `${skill.name}:${userRoot}`,
+                });
             }
         }
         if (selectedPacks.includes('ideas')) {
-            const targetRoot = packRoot('ideas');
-            const ideasResult = await dependencies.installIdeas({
-                assetsRoot,
-                targetRoot,
-            });
-            for (const skill of ideasResult.outdatedSkills) {
-                outdatedSkills.push({ ...skill, targetRoot });
+            for (const targetRoot of packTargets('ideas')) {
+                affectedScopes.add(targetRoot === userRoot ? 'user' : 'project');
+                const ideasResult = await dependencies.installIdeas({
+                    assetsRoot,
+                    targetRoot,
+                });
+                for (const skill of ideasResult.outdatedSkills) {
+                    outdatedSkills.push({
+                        ...skill,
+                        targetRoot,
+                        selectionKey: `${skill.name}:${targetRoot}`,
+                    });
+                }
             }
         }
         if (selectedPacks.includes('docs')) {
-            const targetRoot = packRoot('docs');
-            const docsResult = await dependencies.installDocs({
-                assetsRoot,
-                targetRoot,
-                skills: [...DOCS_SKILLS],
-            });
-            for (const skill of docsResult.outdatedSkills) {
-                outdatedSkills.push({ ...skill, targetRoot });
+            for (const targetRoot of packTargets('docs')) {
+                affectedScopes.add(targetRoot === userRoot ? 'user' : 'project');
+                const docsResult = await dependencies.installDocs({
+                    assetsRoot,
+                    targetRoot,
+                    skills: [...DOCS_SKILLS],
+                });
+                for (const skill of docsResult.outdatedSkills) {
+                    outdatedSkills.push({
+                        ...skill,
+                        targetRoot,
+                        selectionKey: `${skill.name}:${targetRoot}`,
+                    });
+                }
             }
         }
         if (selectedPacks.includes('workflows')) {
+            affectedScopes.add('project');
             const workflowsResult = await dependencies.installWorkflows({
                 assetsRoot,
                 targetRoot: projectRoot,
             });
             for (const skill of workflowsResult.outdatedSkills) {
-                outdatedSkills.push({ ...skill, targetRoot: projectRoot });
+                outdatedSkills.push({
+                    ...skill,
+                    targetRoot: projectRoot,
+                    selectionKey: `${skill.name}:${projectRoot}`,
+                });
             }
             const resolvedRoot = workflowsResult.resolvedProjectsRoot || '.oat/projects/shared';
             const projectsBase = resolvedRoot.replace(/\/[^/]+$/, '');
@@ -285,47 +504,64 @@ export async function runInitTools(context, dependencies) {
             }
         }
         if (selectedPacks.includes('utility')) {
-            const targetRoot = packRoot('utility');
-            const utilityResult = await dependencies.installUtility({
-                assetsRoot,
-                targetRoot,
-                skills: [...UTILITY_SKILLS],
-            });
-            for (const skill of utilityResult.outdatedSkills) {
-                outdatedSkills.push({ ...skill, targetRoot });
+            for (const targetRoot of packTargets('utility')) {
+                affectedScopes.add(targetRoot === userRoot ? 'user' : 'project');
+                const utilityResult = await dependencies.installUtility({
+                    assetsRoot,
+                    targetRoot,
+                    skills: [...UTILITY_SKILLS],
+                });
+                for (const skill of utilityResult.outdatedSkills) {
+                    outdatedSkills.push({
+                        ...skill,
+                        targetRoot,
+                        selectionKey: `${skill.name}:${targetRoot}`,
+                    });
+                }
             }
         }
         if (selectedPacks.includes('project-management')) {
             const targetRoot = projectRoot;
+            affectedScopes.add('project');
             const projectManagementResult = await dependencies.installProjectManagement({
                 assetsRoot,
                 targetRoot,
             });
             for (const skill of projectManagementResult.outdatedSkills) {
-                outdatedSkills.push({ ...skill, targetRoot });
+                outdatedSkills.push({
+                    ...skill,
+                    targetRoot,
+                    selectionKey: `${skill.name}:${targetRoot}`,
+                });
             }
         }
         if (selectedPacks.includes('research')) {
-            const targetRoot = packRoot('research');
-            const researchResult = await dependencies.installResearch({
-                assetsRoot,
-                targetRoot,
-                skills: [...RESEARCH_SKILLS],
-            });
-            for (const skill of researchResult.outdatedSkills) {
-                outdatedSkills.push({ ...skill, targetRoot });
+            for (const targetRoot of packTargets('research')) {
+                affectedScopes.add(targetRoot === userRoot ? 'user' : 'project');
+                const researchResult = await dependencies.installResearch({
+                    assetsRoot,
+                    targetRoot,
+                    skills: [...RESEARCH_SKILLS],
+                });
+                for (const skill of researchResult.outdatedSkills) {
+                    outdatedSkills.push({
+                        ...skill,
+                        targetRoot,
+                        selectionKey: `${skill.name}:${targetRoot}`,
+                    });
+                }
             }
         }
         if (outdatedSkills.length > 0) {
             reportOutdatedSkills(context, outdatedSkills);
             if (context.interactive) {
                 const selectedNames = (await dependencies.selectManyWithAbort('Update outdated skills?', outdatedSkills.map((skill) => ({
-                    label: `${skill.name} (${skill.installed} -> ${skill.bundled})`,
-                    value: skill.name,
+                    label: `${skill.name} (${skill.targetRoot}) (${skill.installed} -> ${skill.bundled})`,
+                    value: skill.selectionKey,
                     checked: true,
                 })), { interactive: context.interactive })) ?? [];
                 const selectedSet = new Set(selectedNames);
-                const selectedOutdated = outdatedSkills.filter((skill) => selectedSet.has(skill.name));
+                const selectedOutdated = outdatedSkills.filter((skill) => selectedSet.has(skill.selectionKey));
                 const updatedNames = await updateOutdatedSkills(selectedOutdated, assetsRoot, dependencies);
                 if (updatedNames.length > 0) {
                     context.logger.info(`Updated outdated skills: ${updatedNames.join(', ')}`);
@@ -348,17 +584,18 @@ export async function runInitTools(context, dependencies) {
             context.logger.info(`AGENTS.md tool packs section ${sectionResult.action}.`);
         }
         const config = await dependencies.readOatConfig(projectRoot);
-        const tools = { ...config.tools };
-        for (const pack of selectedPacks) {
-            tools[pack] = true;
-        }
+        const tools = buildInstalledToolsConfig(selectedPacks, initialPackStates, config.tools);
         await dependencies.writeOatConfig(projectRoot, { ...config, tools });
-        const hasUserScope = selectedPacks.some((pack) => packScopes[pack] === 'user');
-        reportSuccess(context, selectedPacks, hasUserScope ? 'user' : 'project');
+        const affectedScopesList = [...affectedScopes];
+        lastRunInitToolsMetadata = {
+            affectedScopes: affectedScopesList,
+        };
+        reportSuccess(context, packScopeInfo, affectedScopesList);
         process.exitCode = 0;
         return selectedPacks;
     }
     catch (error) {
+        lastRunInitToolsMetadata = null;
         const message = error instanceof Error ? error.message : String(error);
         if (context.json) {
             context.logger.json({ status: 'error', message });
@@ -389,6 +626,7 @@ export function createInitToolsCommand(overrides = {}) {
         .addCommand(createInitToolsResearchCommand())
         .action(async (_options, command) => {
         const context = dependencies.buildCommandContext(readGlobalOptions(command));
-        await runInitTools(context, dependencies);
+        const selectedPacks = await runInitTools(context, dependencies);
+        setInstalledCanonicalPaths(command, canonicalPathsForPacks(selectedPacks));
     });
 }

package/dist/commands/init/tools/install-state.d.ts

@@ -0,0 +1,10 @@
+import type { PackName, ToolInfo } from '../../tools/shared/types.js';
+export type PackInstallLocation = 'not-installed' | 'project' | 'user' | 'both';
+export interface PackInstallState {
+    project: boolean;
+    user: boolean;
+    location: PackInstallLocation;
+}
+export declare function resolvePackInstallLocation(project: boolean, user: boolean): PackInstallLocation;
+export declare function buildPackInstallStateMap<TPack extends PackName>(packs: readonly TPack[], tools: ToolInfo[]): Record<TPack, PackInstallState>;
+//# sourceMappingURL=install-state.d.ts.map

package/dist/commands/init/tools/install-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install-state.d.ts","sourceRoot":"","sources":["../../../../src/commands/init/tools/install-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAEvE,MAAM,MAAM,mBAAmB,GAAG,eAAe,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC;AAEhF,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,mBAAmB,CAAC;CAC/B;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,OAAO,GACZ,mBAAmB,CAcrB;AAED,wBAAgB,wBAAwB,CAAC,KAAK,SAAS,QAAQ,EAC7D,KAAK,EAAE,SAAS,KAAK,EAAE,EACvB,KAAK,EAAE,QAAQ,EAAE,GAChB,MAAM,CAAC,KAAK,EAAE,gBAAgB,CAAC,CA8BjC"}

package/dist/commands/init/tools/install-state.js

@@ -0,0 +1,36 @@
+export function resolvePackInstallLocation(project, user) {
+    if (project && user) {
+        return 'both';
+    }
+    if (project) {
+        return 'project';
+    }
+    if (user) {
+        return 'user';
+    }
+    return 'not-installed';
+}
+export function buildPackInstallStateMap(packs, tools) {
+    const state = Object.fromEntries(packs.map((pack) => [
+        pack,
+        {
+            project: false,
+            user: false,
+            location: 'not-installed',
+        },
+    ]));
+    for (const tool of tools) {
+        if (tool.pack === 'custom' || !(tool.pack in state)) {
+            continue;
+        }
+        const packState = state[tool.pack];
+        if (tool.scope === 'project') {
+            packState.project = true;
+        }
+        else {
+            packState.user = true;
+        }
+        packState.location = resolvePackInstallLocation(packState.project, packState.user);
+    }
+    return state;
+}

package/dist/commands/init/tools/project-management/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/commands/init/tools/project-management/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAEL,KAAK,+BAA+B,EACpC,KAAK,8BAA8B,EACpC,MAAM,8BAA8B,CAAC;AAMtC,UAAU,sCAAsC;IAC9C,mBAAmB,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,cAAc,CAAC;IAChE,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,iBAAiB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACzC,wBAAwB,EAAE,CACxB,OAAO,EAAE,+BAA+B,KACrC,OAAO,CAAC,8BAA8B,CAAC,CAAC;CAC9C;AASD,wBAAgB,uCAAuC,CACrD,SAAS,GAAE,OAAO,CAAC,sCAAsC,CAAM,GAC9D,OAAO,CA0DT"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/commands/init/tools/project-management/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAQ9B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAEL,KAAK,+BAA+B,EACpC,KAAK,8BAA8B,EACpC,MAAM,8BAA8B,CAAC;AAMtC,UAAU,sCAAsC;IAC9C,mBAAmB,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,cAAc,CAAC;IAChE,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,iBAAiB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACzC,wBAAwB,EAAE,CACxB,OAAO,EAAE,+BAA+B,KACrC,OAAO,CAAC,8BAA8B,CAAC,CAAC;CAC9C;AASD,wBAAgB,uCAAuC,CACrD,SAAS,GAAE,OAAO,CAAC,sCAAsC,CAAM,GAC9D,OAAO,CAmET"}