@open-agent-toolkit/cli 0.0.10

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

@@ -0,0 +1,387 @@
+import { join } from 'node:path';
+import { buildCommandContext, } from '../../../app/command-context.js';
+import { copyDirWithStatus } from '../../init/tools/shared/copy-helpers.js';
+import { applyGitignore } from '../../local/apply.js';
+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 { readOatConfig, resolveLocalPaths, } from '../../../config/oat-config.js';
+import { resolveAssetsRoot } from '../../../fs/assets.js';
+import { resolveProjectRoot, resolveScopeRoot } from '../../../fs/paths.js';
+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 { createInitToolsIdeasCommand } from './ideas/index.js';
+import { installIdeas as defaultInstallIdeas, } from './ideas/install-ideas.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 { createInitToolsUtilityCommand } from './utility/index.js';
+import { installUtility as defaultInstallUtility, UTILITY_SKILLS, } 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 DEFAULT_DEPENDENCIES = {
+    buildCommandContext,
+    resolveProjectRoot,
+    resolveScopeRoot,
+    resolveAssetsRoot,
+    selectManyWithAbort,
+    selectWithAbort,
+    installCore: defaultInstallCore,
+    installDocs: defaultInstallDocs,
+    installIdeas: defaultInstallIdeas,
+    installWorkflows: defaultInstallWorkflows,
+    installUtility: defaultInstallUtility,
+    installProjectManagement: defaultInstallProjectManagement,
+    installResearch: defaultInstallResearch,
+    copyDirWithStatus,
+    addLocalPaths,
+    applyGitignore,
+    readOatConfig,
+    resolveLocalPaths,
+    upsertAgentsMdSection,
+    removeAgentsMdSection,
+};
+const USER_ELIGIBLE_PACKS = new Set([
+    'ideas',
+    'docs',
+    'utility',
+    'research',
+]);
+async function resolvePackScopes(context, selections, dependencies) {
+    const scopes = {};
+    // Workflows is always project-only
+    for (const pack of selections) {
+        if (!USER_ELIGIBLE_PACKS.has(pack)) {
+            scopes[pack] = 'project';
+        }
+    }
+    // Core pack is always user-scoped, regardless of user-eligible selection
+    if (selections.includes('core')) {
+        scopes.core = 'user';
+    }
+    const eligiblePacks = selections.filter((pack) => USER_ELIGIBLE_PACKS.has(pack));
+    if (eligiblePacks.length === 0) {
+        return scopes;
+    }
+    // Explicit --scope overrides per-pack selection
+    if (context.scope === 'project') {
+        for (const pack of eligiblePacks) {
+            scopes[pack] = 'project';
+        }
+        return scopes;
+    }
+    if (context.scope === 'user') {
+        for (const pack of eligiblePacks) {
+            scopes[pack] = 'user';
+        }
+        return scopes;
+    }
+    // Non-interactive defaults all to project
+    if (!context.interactive) {
+        for (const pack of eligiblePacks) {
+            scopes[pack] = 'project';
+        }
+        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 userScopeSet = new Set(userScopePacks);
+    for (const pack of eligiblePacks) {
+        scopes[pack] = userScopeSet.has(pack) ? 'user' : 'project';
+    }
+    return scopes;
+}
+function reportSuccess(context, selectedPacks, utilityScope) {
+    if (context.json) {
+        context.logger.json({
+            status: 'ok',
+            selectedPacks,
+            utilityScope,
+        });
+        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');
+    }
+}
+function reportOutdatedSkills(context, outdatedSkills) {
+    if (outdatedSkills.length === 0) {
+        return;
+    }
+    context.logger.info('Outdated skills:');
+    for (const skill of outdatedSkills) {
+        context.logger.info(`  ${skill.name}  ${formatVersionForDisplay(skill.installed)} -> ${formatVersionForDisplay(skill.bundled)}`);
+    }
+}
+async function updateOutdatedSkills(outdatedSkills, assetsRoot, dependencies) {
+    const updatedNames = [];
+    for (const skill of outdatedSkills) {
+        const source = join(assetsRoot, 'skills', skill.name);
+        const destination = join(skill.targetRoot, '.agents', 'skills', skill.name);
+        await dependencies.copyDirWithStatus(source, destination, true);
+        updatedNames.push(skill.name);
+    }
+    return updatedNames;
+}
+const PACK_DESCRIPTIONS = {
+    core: 'Diagnostics and documentation (oat-doctor, oat-docs)',
+    docs: 'Documentation and instruction governance workflows',
+    workflows: 'Project lifecycle (create, discover, plan, implement, review, complete)',
+    ideas: 'Idea capture and refinement',
+    'project-management': 'Local backlog, roadmap, and reference doc management (oat-pjm-* skills)',
+    utility: 'Standalone utilities (skill authoring, maintainability review, code reviews)',
+    research: 'Research, analysis, verification, and synthesis',
+};
+export function buildToolPacksSectionBody(packs) {
+    const userPacks = packs.filter((p) => p.scope === 'user');
+    const hasWorkflows = packs.some((p) => p.pack === 'workflows');
+    const lines = [
+        '## Tool Packs',
+        '',
+        '- **Skills directory:** `.agents/skills/`',
+        '- **Discover available skills:** scan `.agents/skills/*/SKILL.md`',
+        '- **Refresh provider views:** `oat sync --scope all`',
+        '- **Update skills to latest versions:** `oat tools update`',
+    ];
+    if (userPacks.length > 0) {
+        const userPackNames = userPacks.map((p) => p.pack).join(', ');
+        lines.push(`- **User-scoped skills:** \`~/.agents/skills/\` (${userPackNames} packs installed at user scope)`);
+    }
+    lines.push('', '### Installed Packs', '');
+    for (const { pack, scope } of packs) {
+        const suffix = scope === 'user' ? ' _(user scope)_' : '';
+        lines.push(`- **${pack}** — ${PACK_DESCRIPTIONS[pack]}${suffix}`);
+    }
+    if (hasWorkflows) {
+        lines.push('', '### Workflow Execution Continuation', '', '- This guidance applies only to OAT project lifecycle execution, such as `oat-project-implement`, `oat-project-subagent-implement`, and OAT project review/receive flows. It does not apply to non-OAT tasks or ad-hoc work outside the OAT project workflow.', '- When executing an OAT project implementation or OAT project review workflow, do not stop at task boundaries, phase boundaries, or other clean checkpoints unless the configured HiLL checkpoint has been reached, a real blocker exists, or explicit user input is required.', '- Status summaries, completed bookkeeping, and "clean boundary" pauses are not valid stop reasons. After updating tracking artifacts, continue execution until an allowed stop condition applies.');
+    }
+    return lines.join('\n');
+}
+export async function runInitTools(context, dependencies) {
+    try {
+        const selectedPacks = context.interactive
+            ? ((await dependencies.selectManyWithAbort('Select tool packs to install', PACK_CHOICES, { interactive: context.interactive })) ?? [])
+            : ['core', 'ideas', 'docs', 'workflows', 'utility', 'research'];
+        if (!context.interactive) {
+            selectedPacks.push('project-management');
+        }
+        if (selectedPacks.length === 0) {
+            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);
+        function packRoot(pack) {
+            return packScopes[pack] === 'user' ? userRoot : projectRoot;
+        }
+        const assetsRoot = await dependencies.resolveAssetsRoot();
+        const outdatedSkills = [];
+        if (selectedPacks.includes('core')) {
+            // Core pack always installs at user scope, regardless of userEligibleScope
+            const coreResult = await dependencies.installCore({
+                assetsRoot,
+                targetRoot: userRoot,
+            });
+            for (const skill of coreResult.outdatedSkills) {
+                outdatedSkills.push({ ...skill, targetRoot: 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 });
+            }
+        }
+        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 });
+            }
+        }
+        if (selectedPacks.includes('workflows')) {
+            const workflowsResult = await dependencies.installWorkflows({
+                assetsRoot,
+                targetRoot: projectRoot,
+            });
+            for (const skill of workflowsResult.outdatedSkills) {
+                outdatedSkills.push({ ...skill, targetRoot: projectRoot });
+            }
+            const resolvedRoot = workflowsResult.resolvedProjectsRoot || '.oat/projects/shared';
+            const projectsBase = resolvedRoot.replace(/\/[^/]+$/, '');
+            const PR_ARCHIVE_LOCAL_PATHS = [
+                `${projectsBase}/**/pr`,
+                `${projectsBase}/**/reviews/archived`,
+            ];
+            const existingConfig = await dependencies.readOatConfig(projectRoot);
+            const existingLocalPaths = new Set(dependencies.resolveLocalPaths(existingConfig));
+            const alreadyConfigured = PR_ARCHIVE_LOCAL_PATHS.every((p) => existingLocalPaths.has(p));
+            if (!alreadyConfigured) {
+                let makeLocal = true;
+                if (context.interactive) {
+                    const selected = await dependencies.selectWithAbort('Should shared-project PR directories and archived review history be local-only (gitignored) or version-controlled?', [
+                        {
+                            label: 'Local only (recommended)',
+                            value: 'local',
+                            description: 'PR artifacts and archived reviews stay local; active reviews remain tracked until received',
+                        },
+                        {
+                            label: 'Version controlled',
+                            value: 'tracked',
+                            description: 'PR artifacts and archived reviews are committed to the repo too',
+                        },
+                    ], { interactive: context.interactive });
+                    makeLocal = selected !== 'tracked';
+                }
+                if (makeLocal) {
+                    const addResult = await dependencies.addLocalPaths(projectRoot, PR_ARCHIVE_LOCAL_PATHS);
+                    if (addResult.added.length > 0) {
+                        const config = await dependencies.readOatConfig(projectRoot);
+                        const allPaths = dependencies.resolveLocalPaths(config);
+                        await dependencies.applyGitignore(projectRoot, allPaths);
+                    }
+                }
+            }
+        }
+        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 });
+            }
+        }
+        if (selectedPacks.includes('project-management')) {
+            const targetRoot = projectRoot;
+            const projectManagementResult = await dependencies.installProjectManagement({
+                assetsRoot,
+                targetRoot,
+            });
+            for (const skill of projectManagementResult.outdatedSkills) {
+                outdatedSkills.push({ ...skill, 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 });
+            }
+        }
+        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,
+                    checked: true,
+                })), { interactive: context.interactive })) ?? [];
+                const selectedSet = new Set(selectedNames);
+                const selectedOutdated = outdatedSkills.filter((skill) => selectedSet.has(skill.name));
+                const updatedNames = await updateOutdatedSkills(selectedOutdated, assetsRoot, dependencies);
+                if (updatedNames.length > 0) {
+                    context.logger.info(`Updated outdated skills: ${updatedNames.join(', ')}`);
+                }
+            }
+            else {
+                context.logger.info('Non-interactive mode: outdated skills were not updated.');
+                context.logger.info('Use --force to update installed skills.');
+            }
+        }
+        const packScopeInfo = selectedPacks.map((pack) => ({
+            pack,
+            scope: packScopes[pack],
+        }));
+        const sectionBody = buildToolPacksSectionBody(packScopeInfo);
+        const sectionResult = await dependencies.upsertAgentsMdSection(projectRoot, 'tools', sectionBody);
+        // Migrate: remove legacy <!-- OAT workflows --> section if present
+        await dependencies.removeAgentsMdSection(projectRoot, 'workflows');
+        if (!context.json && sectionResult.action !== 'no-change') {
+            context.logger.info(`AGENTS.md tool packs section ${sectionResult.action}.`);
+        }
+        const hasUserScope = selectedPacks.some((pack) => packScopes[pack] === 'user');
+        reportSuccess(context, selectedPacks, hasUserScope ? 'user' : 'project');
+        process.exitCode = 0;
+        return selectedPacks;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (context.json) {
+            context.logger.json({ status: 'error', message });
+        }
+        else {
+            context.logger.error(message);
+        }
+        process.exitCode = 1;
+        return [];
+    }
+}
+export async function runInitToolsWithDefaults(context) {
+    return runInitTools(context, { ...DEFAULT_DEPENDENCIES });
+}
+export function createInitToolsCommand(overrides = {}) {
+    const dependencies = {
+        ...DEFAULT_DEPENDENCIES,
+        ...overrides,
+    };
+    return new Command('tools')
+        .description('Install OAT tool packs (core, ideas, docs, workflows, utility, project-management, research)')
+        .addCommand(createInitToolsCoreCommand())
+        .addCommand(createInitToolsIdeasCommand())
+        .addCommand(createInitToolsDocsCommand())
+        .addCommand(createInitToolsProjectManagementCommand())
+        .addCommand(createInitToolsWorkflowsCommand())
+        .addCommand(createInitToolsUtilityCommand())
+        .addCommand(createInitToolsResearchCommand())
+        .action(async (_options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        await runInitTools(context, dependencies);
+    });
+}

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

@@ -0,0 +1,12 @@
+import { type CommandContext, type GlobalOptions } from '../../../../app/command-context.js';
+import { Command } from 'commander';
+import { type InstallProjectManagementOptions, type InstallProjectManagementResult } from './install-project-management.js';
+interface InitToolsProjectManagementDependencies {
+    buildCommandContext: (options: GlobalOptions) => CommandContext;
+    resolveProjectRoot: (cwd: string) => Promise<string>;
+    resolveAssetsRoot: () => Promise<string>;
+    installProjectManagement: (options: InstallProjectManagementOptions) => Promise<InstallProjectManagementResult>;
+}
+export declare function createInitToolsProjectManagementCommand(overrides?: Partial<InitToolsProjectManagementDependencies>): Command;
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

package/dist/commands/init/tools/project-management/index.js

@@ -0,0 +1,61 @@
+import { buildCommandContext, } from '../../../../app/command-context.js';
+import { readGlobalOptions } from '../../../shared/shared.utils.js';
+import { resolveAssetsRoot } from '../../../../fs/assets.js';
+import { resolveProjectRoot } from '../../../../fs/paths.js';
+import { Command } from 'commander';
+import { installProjectManagement as defaultInstallProjectManagement, } from './install-project-management.js';
+const DEFAULT_DEPENDENCIES = {
+    buildCommandContext,
+    resolveProjectRoot,
+    resolveAssetsRoot,
+    installProjectManagement: defaultInstallProjectManagement,
+};
+export function createInitToolsProjectManagementCommand(overrides = {}) {
+    const dependencies = {
+        ...DEFAULT_DEPENDENCIES,
+        ...overrides,
+    };
+    return new Command('project-management')
+        .description('Install OAT project-management skills and templates')
+        .option('--force', 'Overwrite existing files where applicable')
+        .action(async (options, command) => {
+        try {
+            const context = dependencies.buildCommandContext(readGlobalOptions(command));
+            const targetRoot = await dependencies.resolveProjectRoot(context.cwd);
+            const assetsRoot = await dependencies.resolveAssetsRoot();
+            const result = await dependencies.installProjectManagement({
+                assetsRoot,
+                targetRoot,
+                force: options.force,
+            });
+            if (context.json) {
+                context.logger.json({
+                    status: 'ok',
+                    scope: 'project',
+                    targetRoot,
+                    assetsRoot,
+                    result,
+                });
+            }
+            else {
+                context.logger.info('Installed project-management tool pack.');
+                context.logger.info(`Target root: ${targetRoot}`);
+                context.logger.info(`Skills: copied=${result.copiedSkills.length}, updated=${result.updatedSkills.length}, skipped=${result.skippedSkills.length}`);
+                context.logger.info(`Templates: copied=${result.copiedTemplates.length}, updated=${result.updatedTemplates.length}, skipped=${result.skippedTemplates.length}`);
+                context.logger.info('Run: oat sync --scope project');
+            }
+            process.exitCode = 0;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const context = dependencies.buildCommandContext(readGlobalOptions(command));
+            if (context.json) {
+                context.logger.json({ status: 'error', message });
+            }
+            else {
+                context.logger.error(message);
+            }
+            process.exitCode = 1;
+        }
+    });
+}

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

@@ -0,0 +1,22 @@
+import { PROJECT_MANAGEMENT_SCRIPTS, PROJECT_MANAGEMENT_SKILLS, PROJECT_MANAGEMENT_TEMPLATES } from '../../../init/tools/shared/skill-manifest.js';
+export { PROJECT_MANAGEMENT_SCRIPTS, PROJECT_MANAGEMENT_SKILLS, PROJECT_MANAGEMENT_TEMPLATES, };
+export interface InstallProjectManagementOptions {
+    assetsRoot: string;
+    targetRoot: string;
+    force?: boolean;
+}
+export interface InstallProjectManagementResult {
+    copiedSkills: string[];
+    updatedSkills: string[];
+    skippedSkills: string[];
+    outdatedSkills: Array<{
+        name: string;
+        installed: string | null;
+        bundled: string | null;
+    }>;
+    copiedTemplates: string[];
+    updatedTemplates: string[];
+    skippedTemplates: string[];
+}
+export declare function installProjectManagement(options: InstallProjectManagementOptions): Promise<InstallProjectManagementResult>;
+//# sourceMappingURL=install-project-management.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"install-project-management.d.ts","sourceRoot":"","sources":["../../../../../src/commands/init/tools/project-management/install-project-management.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,EACzB,4BAA4B,EAC7B,MAAM,4CAA4C,CAAC;AAEpD,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,EACzB,4BAA4B,GAC7B,CAAC;AAEF,MAAM,WAAW,+BAA+B;IAC9C,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,8BAA8B;IAC7C,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,cAAc,EAAE,KAAK,CAAC;QACpB,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;QACzB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;KACxB,CAAC,CAAC;IACH,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,+BAA+B,GACvC,OAAO,CAAC,8BAA8B,CAAC,CAoDzC"}

package/dist/commands/init/tools/project-management/install-project-management.js

@@ -0,0 +1,52 @@
+import { join } from 'node:path';
+import { copyDirWithVersionCheck, copyFileWithStatus, } from '../../../init/tools/shared/copy-helpers.js';
+import { PROJECT_MANAGEMENT_SCRIPTS, PROJECT_MANAGEMENT_SKILLS, PROJECT_MANAGEMENT_TEMPLATES, } from '../../../init/tools/shared/skill-manifest.js';
+export { PROJECT_MANAGEMENT_SCRIPTS, PROJECT_MANAGEMENT_SKILLS, PROJECT_MANAGEMENT_TEMPLATES, };
+export async function installProjectManagement(options) {
+    const force = options.force ?? false;
+    const result = {
+        copiedSkills: [],
+        updatedSkills: [],
+        skippedSkills: [],
+        outdatedSkills: [],
+        copiedTemplates: [],
+        updatedTemplates: [],
+        skippedTemplates: [],
+    };
+    for (const skill of PROJECT_MANAGEMENT_SKILLS) {
+        const source = join(options.assetsRoot, 'skills', skill);
+        const destination = join(options.targetRoot, '.agents', 'skills', skill);
+        const copyResult = await copyDirWithVersionCheck(source, destination, force);
+        if (copyResult.status === 'copied') {
+            result.copiedSkills.push(skill);
+        }
+        else if (copyResult.status === 'updated') {
+            result.updatedSkills.push(skill);
+        }
+        else if (copyResult.status === 'outdated') {
+            result.outdatedSkills.push({
+                name: skill,
+                installed: copyResult.installedVersion ?? null,
+                bundled: copyResult.bundledVersion ?? null,
+            });
+        }
+        else {
+            result.skippedSkills.push(skill);
+        }
+    }
+    for (const template of PROJECT_MANAGEMENT_TEMPLATES) {
+        const source = join(options.assetsRoot, 'templates', template);
+        const destination = join(options.targetRoot, '.oat', 'templates', template);
+        const copyStatus = await copyFileWithStatus(source, destination, force);
+        if (copyStatus === 'copied') {
+            result.copiedTemplates.push(template);
+        }
+        else if (copyStatus === 'updated') {
+            result.updatedTemplates.push(template);
+        }
+        else {
+            result.skippedTemplates.push(template);
+        }
+    }
+    return result;
+}

package/dist/commands/init/tools/research/index.d.ts

@@ -0,0 +1,17 @@
+import { type CommandContext, type GlobalOptions } from '../../../../app/command-context.js';
+import { type MultiSelectChoice, type PromptContext } from '../../../shared/shared.prompts.js';
+import { Command } from 'commander';
+import { type InstallResearchOptions, type InstallResearchResult } from './install-research.js';
+type ResearchScope = 'project' | 'user';
+interface InitToolsResearchDependencies {
+    buildCommandContext: (options: GlobalOptions) => CommandContext;
+    resolveProjectRoot: (cwd: string) => Promise<string>;
+    resolveScopeRoot: (scope: ResearchScope, cwd: string, home: string) => string;
+    resolveAssetsRoot: () => Promise<string>;
+    installResearch: (options: InstallResearchOptions) => Promise<InstallResearchResult>;
+    selectManyWithAbort: <T extends string>(message: string, choices: MultiSelectChoice<T>[], ctx: PromptContext) => Promise<T[] | null>;
+    confirmAction: (message: string, ctx: PromptContext) => Promise<boolean>;
+}
+export declare function createInitToolsResearchCommand(overrides?: Partial<InitToolsResearchDependencies>): Command;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/init/tools/research/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/commands/init/tools/research/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAEnB,MAAM,iCAAiC,CAAC;AAIzC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAEL,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAE3B,MAAM,oBAAoB,CAAC;AAM5B,KAAK,aAAa,GAAG,SAAS,GAAG,MAAM,CAAC;AAExC,UAAU,6BAA6B;IACrC,mBAAmB,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,cAAc,CAAC;IAChE,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,gBAAgB,EAAE,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAC9E,iBAAiB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACzC,eAAe,EAAE,CACf,OAAO,EAAE,sBAAsB,KAC5B,OAAO,CAAC,qBAAqB,CAAC,CAAC;IACpC,mBAAmB,EAAE,CAAC,CAAC,SAAS,MAAM,EACpC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,EAC/B,GAAG,EAAE,aAAa,KACf,OAAO,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC;IACzB,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC1E;AAqID,wBAAgB,8BAA8B,CAC5C,SAAS,GAAE,OAAO,CAAC,6BAA6B,CAAM,GACrD,OAAO,CAeT"}