codingbuddy 5.2.0 → 5.4.0

package/dist/src/cli/completion/completion.d.ts

@@ -0,0 +1,16 @@
+export declare const COMMANDS: readonly ["init", "install", "search", "plugins", "update", "uninstall", "mcp", "tui", "completion"];
+export declare const GLOBAL_FLAGS: readonly ["--help", "--version"];
+export declare const COMMAND_FLAGS: Record<string, readonly string[]>;
+export declare function getPluginNames(projectRoot: string): string[];
+export declare function generateBashCompletion(): string;
+export declare function generateZshCompletion(): string;
+export declare function generateFishCompletion(): string;
+export declare function generateCompletion(shell: string): string | null;
+export interface CompletionOptions {
+    shell: string;
+}
+export interface CompletionResult {
+    success: boolean;
+    error?: string;
+}
+export declare function runCompletion(options: CompletionOptions): CompletionResult;

package/dist/src/cli/completion/completion.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMMAND_FLAGS = exports.GLOBAL_FLAGS = exports.COMMANDS = void 0;
+exports.getPluginNames = getPluginNames;
+exports.generateBashCompletion = generateBashCompletion;
+exports.generateZshCompletion = generateZshCompletion;
+exports.generateFishCompletion = generateFishCompletion;
+exports.generateCompletion = generateCompletion;
+exports.runCompletion = runCompletion;
+const fs_1 = require("fs");
+const path_1 = require("path");
+exports.COMMANDS = [
+    'init',
+    'install',
+    'search',
+    'plugins',
+    'update',
+    'uninstall',
+    'mcp',
+    'tui',
+    'completion',
+];
+exports.GLOBAL_FLAGS = ['--help', '--version'];
+exports.COMMAND_FLAGS = {
+    init: ['--force', '--yes', '--api-key'],
+    install: ['--force'],
+    uninstall: ['--yes'],
+    tui: ['--restart'],
+    completion: ['bash', 'zsh', 'fish'],
+};
+const COMMAND_DESCRIPTIONS = {
+    init: 'Initialize configuration',
+    install: 'Install a plugin from git repository',
+    search: 'Search plugins in the registry',
+    plugins: 'List installed plugins',
+    update: 'Check and update outdated plugins',
+    uninstall: 'Uninstall a plugin',
+    mcp: 'Start MCP server (stdio mode)',
+    tui: 'Monitor agent execution in real-time',
+    completion: 'Generate shell completion script',
+};
+function getPluginNames(projectRoot) {
+    const pluginsPath = (0, path_1.join)(projectRoot, '.codingbuddy', 'plugins.json');
+    if (!(0, fs_1.existsSync)(pluginsPath)) {
+        return [];
+    }
+    try {
+        const raw = (0, fs_1.readFileSync)(pluginsPath, 'utf-8');
+        const data = JSON.parse(raw);
+        return (data.plugins ?? []).map(p => p.name);
+    }
+    catch {
+        return [];
+    }
+}
+function generateBashCompletion() {
+    const cmds = exports.COMMANDS.join(' ');
+    const globalFlags = exports.GLOBAL_FLAGS.join(' ');
+    const initFlags = (exports.COMMAND_FLAGS.init ?? []).join(' ');
+    const installFlags = (exports.COMMAND_FLAGS.install ?? []).join(' ');
+    const uninstallFlags = (exports.COMMAND_FLAGS.uninstall ?? []).join(' ');
+    const tuiFlags = (exports.COMMAND_FLAGS.tui ?? []).join(' ');
+    return `#!/bin/bash
+# codingbuddy bash completion
+# Install: codingbuddy completion bash >> ~/.bashrc
+#   or:    codingbuddy completion bash > /etc/bash_completion.d/codingbuddy
+
+_codingbuddy_get_plugin_names() {
+  local plugins_file=".codingbuddy/plugins.json"
+  if [[ -f "$plugins_file" ]]; then
+    grep -o '"name"[[:space:]]*:[[:space:]]*"[^"]*"' "$plugins_file" | sed 's/"name"[[:space:]]*:[[:space:]]*"\\([^"]*\\)"/\\1/'
+  fi
+}
+
+_codingbuddy_completions() {
+  local cur prev commands
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  commands="${cmds}"
+
+  # Complete commands at position 1
+  if [[ \${COMP_CWORD} -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "$commands ${globalFlags}" -- "$cur") )
+    return
+  fi
+
+  # Complete based on command
+  case "\${COMP_WORDS[1]}" in
+    init)
+      COMPREPLY=( $(compgen -W "${initFlags}" -- "$cur") )
+      ;;
+    install)
+      COMPREPLY=( $(compgen -W "${installFlags}" -- "$cur") )
+      ;;
+    uninstall)
+      if [[ \${COMP_CWORD} -eq 2 ]]; then
+        local plugins=$(_codingbuddy_get_plugin_names)
+        COMPREPLY=( $(compgen -W "$plugins ${uninstallFlags}" -- "$cur") )
+      else
+        COMPREPLY=( $(compgen -W "${uninstallFlags}" -- "$cur") )
+      fi
+      ;;
+    update)
+      if [[ \${COMP_CWORD} -eq 2 ]]; then
+        local plugins=$(_codingbuddy_get_plugin_names)
+        COMPREPLY=( $(compgen -W "$plugins" -- "$cur") )
+      fi
+      ;;
+    tui)
+      COMPREPLY=( $(compgen -W "${tuiFlags}" -- "$cur") )
+      ;;
+    completion)
+      COMPREPLY=( $(compgen -W "bash zsh fish" -- "$cur") )
+      ;;
+  esac
+}
+
+complete -F _codingbuddy_completions codingbuddy
+`;
+}
+function generateZshCompletion() {
+    const cmdEntries = exports.COMMANDS.map(cmd => `      '${cmd}:${COMMAND_DESCRIPTIONS[cmd] ?? cmd}'`).join('\n');
+    const initFlags = (exports.COMMAND_FLAGS.init ?? [])
+        .map(f => `        '${f}[${f === '--force' ? 'Overwrite existing config' : f === '--yes' ? 'Accept defaults' : 'Anthropic API key'}]'`)
+        .join('\n');
+    const installFlags = (exports.COMMAND_FLAGS.install ?? [])
+        .map(f => `        '${f}[Force install]'`)
+        .join('\n');
+    const uninstallFlags = (exports.COMMAND_FLAGS.uninstall ?? [])
+        .map(f => `        '${f}[Skip confirmation]'`)
+        .join('\n');
+    return `#compdef codingbuddy
+# codingbuddy zsh completion
+# Install: codingbuddy completion zsh > ~/.zsh/completions/_codingbuddy
+#   then add to ~/.zshrc: fpath=(~/.zsh/completions $fpath)
+
+_codingbuddy_get_plugin_names() {
+  local plugins_file=".codingbuddy/plugins.json"
+  if [[ -f "$plugins_file" ]]; then
+    grep -o '"name"[[:space:]]*:[[:space:]]*"[^"]*"' "$plugins_file" | sed 's/"name"[[:space:]]*:[[:space:]]*"\\([^"]*\\)"/\\1/'
+  fi
+}
+
+_codingbuddy() {
+  local -a commands
+  commands=(
+${cmdEntries}
+  )
+
+  _arguments -C \\
+    '1:command:->command' \\
+    '*::arg:->args'
+
+  case "$state" in
+    command)
+      _describe 'command' commands
+      compadd -- --help --version
+      ;;
+    args)
+      case "\${words[1]}" in
+        init)
+          _arguments \\
+${initFlags}
+          ;;
+        install)
+          _arguments \\
+${installFlags}
+          ;;
+        uninstall)
+          if (( CURRENT == 2 )); then
+            local -a plugins
+            plugins=(\${(f)"$(_codingbuddy_get_plugin_names)"})
+            compadd -a plugins
+          fi
+          _arguments \\
+${uninstallFlags}
+          ;;
+        update)
+          if (( CURRENT == 2 )); then
+            local -a plugins
+            plugins=(\${(f)"$(_codingbuddy_get_plugin_names)"})
+            compadd -a plugins
+          fi
+          ;;
+        tui)
+          _arguments \\
+            '--restart[Restart TUI client]'
+          ;;
+        completion)
+          compadd bash zsh fish
+          ;;
+      esac
+      ;;
+  esac
+}
+
+_codingbuddy "$@"
+`;
+}
+function generateFishCompletion() {
+    const noSubcommandCond = '__fish_seen_subcommand_from init install search plugins update uninstall mcp tui completion';
+    const lines = [
+        '# codingbuddy fish completion',
+        '# Install: codingbuddy completion fish > ~/.config/fish/completions/codingbuddy.fish',
+        '',
+        '# Helper: get plugin names from plugins.json',
+        'function __codingbuddy_plugin_names',
+        '  set -l plugins_file ".codingbuddy/plugins.json"',
+        '  if test -f $plugins_file',
+        '    string match -rg \'"name"\\s*:\\s*"([^"]*)"\'  < $plugins_file',
+        '  end',
+        'end',
+        '',
+        '# Disable file completions by default',
+        'complete -c codingbuddy -f',
+        '',
+        '# Commands (only when no subcommand given)',
+    ];
+    for (const cmd of exports.COMMANDS) {
+        const desc = COMMAND_DESCRIPTIONS[cmd] ?? cmd;
+        lines.push(`complete -c codingbuddy -n "not ${noSubcommandCond}" -a "${cmd}" -d "${desc}"`);
+    }
+    lines.push('');
+    lines.push('# Global flags');
+    lines.push(`complete -c codingbuddy -n "not ${noSubcommandCond}" -l help -d "Show help"`);
+    lines.push(`complete -c codingbuddy -n "not ${noSubcommandCond}" -l version -d "Show version"`);
+    lines.push('');
+    lines.push('# init flags');
+    lines.push('complete -c codingbuddy -n "__fish_seen_subcommand_from init" -l force -s f -d "Overwrite existing config"');
+    lines.push('complete -c codingbuddy -n "__fish_seen_subcommand_from init" -l yes -s y -d "Accept defaults"');
+    lines.push('complete -c codingbuddy -n "__fish_seen_subcommand_from init" -l api-key -d "Anthropic API key"');
+    lines.push('');
+    lines.push('# install flags');
+    lines.push('complete -c codingbuddy -n "__fish_seen_subcommand_from install" -l force -s f -d "Force install"');
+    lines.push('');
+    lines.push('# uninstall - dynamic plugin names + flags');
+    lines.push('complete -c codingbuddy -n "__fish_seen_subcommand_from uninstall" -a "(__codingbuddy_plugin_names)" -d "Plugin name"');
+    lines.push('complete -c codingbuddy -n "__fish_seen_subcommand_from uninstall" -l yes -s y -d "Skip confirmation"');
+    lines.push('');
+    lines.push('# update - dynamic plugin names');
+    lines.push('complete -c codingbuddy -n "__fish_seen_subcommand_from update" -a "(__codingbuddy_plugin_names)" -d "Plugin name"');
+    lines.push('');
+    lines.push('# tui flags');
+    lines.push('complete -c codingbuddy -n "__fish_seen_subcommand_from tui" -l restart -d "Restart TUI client"');
+    lines.push('');
+    lines.push('# completion subcommands');
+    lines.push('complete -c codingbuddy -n "__fish_seen_subcommand_from completion" -a "bash zsh fish" -d "Shell type"');
+    lines.push('');
+    return lines.join('\n');
+}
+function generateCompletion(shell) {
+    switch (shell) {
+        case 'bash':
+            return generateBashCompletion();
+        case 'zsh':
+            return generateZshCompletion();
+        case 'fish':
+            return generateFishCompletion();
+        default:
+            return null;
+    }
+}
+function runCompletion(options) {
+    if (!options.shell) {
+        process.stderr.write('Error: Missing shell type. Usage: codingbuddy completion <bash|zsh|fish>\n');
+        return { success: false, error: 'Missing shell type' };
+    }
+    const script = generateCompletion(options.shell);
+    if (!script) {
+        process.stderr.write(`Error: Unsupported shell "${options.shell}". Supported: bash, zsh, fish\n`);
+        return { success: false, error: `Unsupported shell: ${options.shell}` };
+    }
+    process.stdout.write(script);
+    return { success: true };
+}
+//# sourceMappingURL=completion.js.map

package/dist/src/cli/completion/index.d.ts

@@ -0,0 +1,2 @@
+export { runCompletion, generateCompletion } from './completion';
+export type { CompletionOptions, CompletionResult } from './completion';

package/dist/src/cli/completion/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCompletion = exports.runCompletion = void 0;
+var completion_1 = require("./completion");
+Object.defineProperty(exports, "runCompletion", { enumerable: true, get: function () { return completion_1.runCompletion; } });
+Object.defineProperty(exports, "generateCompletion", { enumerable: true, get: function () { return completion_1.generateCompletion; } });
+//# sourceMappingURL=index.js.map

package/dist/src/cli/plugin/create-plugin.command.d.ts

@@ -0,0 +1,21 @@
+export interface CreatePluginOptions {
+    name: string;
+    outputDir: string;
+    template: 'minimal' | 'full';
+    description?: string;
+    author?: string;
+}
+export interface CreatePluginResult {
+    success: boolean;
+    pluginDir?: string;
+    error?: string;
+}
+export interface TemplateContext {
+    name: string;
+    description: string;
+    author: string;
+}
+export declare function validatePluginName(name: string): boolean;
+export declare function generateMinimalTemplate(ctx: TemplateContext): Record<string, string>;
+export declare function generateFullTemplate(ctx: TemplateContext): Record<string, string>;
+export declare function runCreatePlugin(options: CreatePluginOptions): Promise<CreatePluginResult>;

package/dist/src/cli/plugin/create-plugin.command.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePluginName = validatePluginName;
+exports.generateMinimalTemplate = generateMinimalTemplate;
+exports.generateFullTemplate = generateFullTemplate;
+exports.runCreatePlugin = runCreatePlugin;
+const fs = require("fs");
+const path = require("path");
+const child_process_1 = require("child_process");
+const console_1 = require("../utils/console");
+const PLUGIN_NAME_REGEX = /^[a-z][a-z0-9-]*$/;
+function validatePluginName(name) {
+    return PLUGIN_NAME_REGEX.test(name);
+}
+function getDefaultAuthor() {
+    try {
+        return (0, child_process_1.execSync)('git config user.name', { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function generateMinimalTemplate(ctx) {
+    const manifest = {
+        name: ctx.name,
+        version: '1.0.0',
+        description: ctx.description,
+        author: ctx.author,
+        provides: {
+            agents: [],
+            rules: [],
+            skills: [],
+            checklists: [],
+        },
+    };
+    const readme = `# ${ctx.name}
+
+${ctx.description}
+
+## Installation
+
+\`\`\`bash
+codingbuddy install ./${ctx.name}
+\`\`\`
+
+## Author
+
+${ctx.author}
+`;
+    const gitignore = `node_modules/
+dist/
+.DS_Store
+`;
+    return {
+        'plugin.json': JSON.stringify(manifest, null, 2),
+        'README.md': readme,
+        '.gitignore': gitignore,
+    };
+}
+function generateFullTemplate(ctx) {
+    const minimalFiles = generateMinimalTemplate(ctx);
+    const manifest = JSON.parse(minimalFiles['plugin.json']);
+    manifest.provides = {
+        agents: ['agents/example-agent.json'],
+        rules: ['rules/example-rule.md'],
+        skills: ['skills/example-skill.md'],
+        checklists: ['checklists/example-checklist.json'],
+    };
+    const exampleAgent = {
+        name: 'Example Agent',
+        description: `Example specialist agent for ${ctx.name}`,
+        role: {
+            title: 'Example Specialist',
+            expertise: ['example-domain'],
+        },
+        activation_message: {
+            formatted: '🤖 example-agent [Example Specialist]',
+        },
+    };
+    const exampleSkill = `# Example Skill
+
+## Purpose
+
+An example skill provided by ${ctx.name}.
+
+## Instructions
+
+Describe the skill instructions here.
+`;
+    const exampleRule = `# Example Rule
+
+## Description
+
+An example rule provided by ${ctx.name}.
+
+## Guidelines
+
+- Guideline 1
+- Guideline 2
+`;
+    const exampleChecklist = {
+        name: 'Example Checklist',
+        description: `Example checklist from ${ctx.name}`,
+        items: [
+            {
+                id: 'example-1',
+                text: 'Check example condition',
+                severity: 'medium',
+            },
+        ],
+    };
+    return {
+        ...minimalFiles,
+        'plugin.json': JSON.stringify(manifest, null, 2),
+        'agents/example-agent.json': JSON.stringify(exampleAgent, null, 2),
+        'skills/example-skill.md': exampleSkill,
+        'rules/example-rule.md': exampleRule,
+        'checklists/example-checklist.json': JSON.stringify(exampleChecklist, null, 2),
+    };
+}
+async function runCreatePlugin(options) {
+    const console = (0, console_1.createConsoleUtils)();
+    if (!validatePluginName(options.name)) {
+        const msg = `Invalid plugin name "${options.name}". Must match /^[a-z][a-z0-9-]*$/`;
+        console.log.error(msg);
+        return { success: false, error: msg };
+    }
+    const pluginDir = path.join(options.outputDir, options.name);
+    if (fs.existsSync(pluginDir)) {
+        const msg = `Directory "${pluginDir}" already exists`;
+        console.log.error(msg);
+        return { success: false, error: msg };
+    }
+    const author = options.author ?? getDefaultAuthor();
+    const description = options.description ?? `A CodingBuddy plugin: ${options.name}`;
+    const ctx = {
+        name: options.name,
+        description,
+        author,
+    };
+    const files = options.template === 'full' ? generateFullTemplate(ctx) : generateMinimalTemplate(ctx);
+    console.log.step('🔧', `Scaffolding plugin "${options.name}" (${options.template} template)...`);
+    for (const [filePath, content] of Object.entries(files)) {
+        const fullPath = path.join(pluginDir, filePath);
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        fs.writeFileSync(fullPath, content, 'utf-8');
+    }
+    console.log.success(`Plugin "${options.name}" created at ${pluginDir}`);
+    return { success: true, pluginDir };
+}
+//# sourceMappingURL=create-plugin.command.js.map

package/dist/src/cli/run-tui.d.ts

@@ -1,3 +1,4 @@
+export declare function resolveHudStateDir(): string;
 export declare function runTui(options?: {
     restart?: boolean;
 }): Promise<void>;

package/dist/src/cli/run-tui.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveHudStateDir = resolveHudStateDir;
 exports.runTui = runTui;
 const path = require("node:path");
 const os = require("node:os");
@@ -7,6 +8,11 @@ const ipc_types_1 = require("../tui/ipc/ipc.types");
 const instance_registry_1 = require("../tui/ipc/instance-registry");
 const restart_tui_1 = require("./restart-tui");
 const CLIENT_SHUTDOWN_TIMEOUT_MS = 3000;
+function resolveHudStateDir() {
+    return (process.env.CODINGBUDDY_HUD_STATE_DIR ??
+        process.env.CLAUDE_PLUGIN_DATA ??
+        path.join(os.homedir(), '.codingbuddy'));
+}
 async function runTui(options = {}) {
     if (options.restart) {
         const result = await (0, restart_tui_1.restartTui)();
@@ -46,7 +52,7 @@ async function runTui(options = {}) {
         const { HudFileBridge } = await Promise.resolve().then(() => require('../tui/events'));
         const sessions = manager.getSessions();
         if (sessions.length > 0) {
-            const hudStatePath = path.join(process.env.CODINGBUDDY_HUD_STATE_DIR ?? path.join(os.homedir(), '.codingbuddy'), 'hud-state.json');
+            const hudStatePath = path.join(resolveHudStateDir(), 'hud-state.json');
             const bridge = new HudFileBridge(sessions[0].eventBus, hudStatePath);
             bridge.start();
             hudBridge = bridge;

package/dist/src/config/config.schema.d.ts

@@ -261,6 +261,9 @@ export declare const CodingBuddyConfigSchema: z.ZodObject<{
         maxArrayItems: z.ZodDefault<z.ZodNumber>;
         maxItemLength: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
+    experimental: z.ZodOptional<z.ZodObject<{
+        teamsCoordination: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    }, z.core.$strip>>;
     upstreamRepos: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     keyFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
     avoid: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/src/config/config.schema.js

@@ -98,6 +98,11 @@ exports.CodingBuddyConfigSchema = zod_1.z.object({
     auto: AutoConfigSchema.optional(),
     release: ReleaseConfigSchema.optional(),
     context: ContextConfigSchema.optional(),
+    experimental: zod_1.z
+        .object({
+        teamsCoordination: zod_1.z.boolean().default(false).optional(),
+    })
+        .optional(),
     upstreamRepos: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
     keyFiles: zod_1.z.array(zod_1.z.string()).optional(),
     avoid: zod_1.z.array(zod_1.z.string()).optional(),

package/dist/src/keyword/keyword.module.js

@@ -16,6 +16,7 @@ const skill_module_1 = require("../skill/skill.module");
 const skill_recommendation_service_1 = require("../skill/skill-recommendation.service");
 const agent_module_1 = require("../agent/agent.module");
 const agent_service_1 = require("../agent/agent.service");
+const agent_stack_service_1 = require("../agent/agent-stack.service");
 const agent_utils_1 = require("../shared/agent.utils");
 const client_type_1 = require("../shared/client-type");
 const keyword_service_1 = require("./keyword.service");
@@ -30,7 +31,7 @@ exports.KeywordModule = KeywordModule = __decorate([
         providers: [
             {
                 provide: exports.KEYWORD_SERVICE,
-                useFactory: (rulesService, configService, skillRecommendationService, agentService) => {
+                useFactory: (rulesService, configService, skillRecommendationService, agentService, agentStackService) => {
                     const logger = new common_1.Logger('KeywordModule');
                     const loadConfig = async () => {
                         const content = await rulesService.getRuleContent('keyword-modes.json');
@@ -157,6 +158,35 @@ exports.KeywordModule = KeywordModule = __decorate([
                             return null;
                         }
                     };
+                    const loadStacks = async () => {
+                        try {
+                            const summaries = await agentStackService.listStacks();
+                            const results = [];
+                            for (const summary of summaries) {
+                                try {
+                                    const full = await agentStackService.resolveStack(summary.name);
+                                    results.push({
+                                        name: full.name,
+                                        category: full.category,
+                                        tags: full.tags,
+                                        specialist_agents: full.specialist_agents,
+                                    });
+                                }
+                                catch {
+                                    results.push({
+                                        name: summary.name,
+                                        category: summary.category,
+                                        tags: summary.tags ?? [],
+                                    });
+                                }
+                            }
+                            return results;
+                        }
+                        catch (error) {
+                            logger.debug(`Failed to load agent stacks: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                            return [];
+                        }
+                    };
                     const options = {
                         primaryAgentResolver,
                         loadAutoConfigFn: loadAutoConfig,
@@ -165,10 +195,17 @@ exports.KeywordModule = KeywordModule = __decorate([
                         loadAgentSystemPromptFn: loadAgentSystemPrompt,
                         getMaxIncludedSkillsFn: getMaxIncludedSkills,
                         getClientTypeFn: () => (0, client_type_1.resolveClientType)(configService.getClientName()),
+                        loadStacksFn: loadStacks,
                     };
                     return new keyword_service_1.KeywordService(loadConfig, loadRule, loadAgent, options);
                 },
-                inject: [rules_service_1.RulesService, config_service_1.ConfigService, skill_recommendation_service_1.SkillRecommendationService, agent_service_1.AgentService],
+                inject: [
+                    rules_service_1.RulesService,
+                    config_service_1.ConfigService,
+                    skill_recommendation_service_1.SkillRecommendationService,
+                    agent_service_1.AgentService,
+                    agent_stack_service_1.AgentStackService,
+                ],
             },
         ],
         exports: [exports.KEYWORD_SERVICE],

package/dist/src/keyword/keyword.service.d.ts

@@ -2,6 +2,7 @@ import { type Mode, type RuleContent, type ParseModeResult, type KeywordModesCon
 import { type VerbosityLevel } from '../shared/verbosity.types';
 import { PrimaryAgentResolver } from './primary-agent-resolver';
 import { type ClientType } from '../shared/client-type';
+import { type StackMatchInput } from '../agent/stack-matcher';
 export interface ParseModeOptions {
     recommendedActAgent?: string;
     context?: ResolutionContext;
@@ -19,6 +20,7 @@ export interface KeywordServiceOptions {
     getMaxIncludedSkillsFn?: () => Promise<number | null>;
     getClientTypeFn?: () => ClientType;
     trackRuleUsageFn?: (ruleNames: string[]) => void;
+    loadStacksFn?: () => Promise<StackMatchInput[]>;
 }
 export interface SkillRecommendationInfo {
     skillName: string;
@@ -54,6 +56,7 @@ export declare class KeywordService {
     private readonly getMaxIncludedSkillsFn?;
     private readonly getClientTypeFn?;
     private readonly trackRuleUsageFn?;
+    private readonly loadStacksFn?;
     private static readonly CONTEXT_SPECIALIST_PATTERNS;
     constructor(loadConfigFn: () => Promise<KeywordModesConfig>, loadRuleFn: (path: string) => Promise<string>, loadAgentInfoFn?: ((agentName: string) => Promise<unknown>) | undefined, options?: KeywordServiceOptions);
     parseMode(prompt: string, options?: ParseModeOptions): Promise<ParseModeResult>;
@@ -73,6 +76,8 @@ export declare class KeywordService {
     private addAutoConfigToResult;
     private addComplexityToResult;
     private addIncludedSkillsToResult;
+    private enforceRequiredAgentSkills;
+    private extractRequiredSkillNames;
     private getMaxIncludedSkills;
     private loadSkillsInParallel;
     private addIncludedAgentToResult;