codingbuddy 5.1.3 → 5.3.0

package/dist/src/agent/agent.types.d.ts

@@ -1,4 +1,17 @@
-import type { Mode } from '../keyword/keyword.types';
+type Mode = 'PLAN' | 'ACT' | 'EVAL' | 'AUTO';
+import type { DispatchedAgent, TaskmaestroDispatch, TeamsDispatch, VisibilityConfig, ExecutionPlan } from './execution-plan.types';
+export interface AgentStack {
+    name: string;
+    description: string;
+    category: string;
+    tags: string[];
+    primary_agent: string;
+    specialist_agents: string[];
+    recommended_for?: {
+        file_patterns?: string[];
+        modes?: string[];
+    };
+}
 export interface AgentContext {
     mode: Mode;
     targetFiles?: string[];
@@ -31,50 +44,7 @@ export interface ParallelAgentSet {
     parallelExecutionHint: string;
     failedAgents?: FailedAgent[];
 }
-export interface DispatchParams {
-    subagent_type: 'general-purpose';
-    prompt: string;
-    description: string;
-    run_in_background?: true;
-}
-export interface DispatchedAgent {
-    name: string;
-    displayName: string;
-    description: string;
-    dispatchParams: DispatchParams;
-}
-export interface TaskmaestroAssignment {
-    name: string;
-    displayName: string;
-    prompt: string;
-}
-export interface TaskmaestroDispatch {
-    sessionName: string;
-    paneCount: number;
-    assignments: TaskmaestroAssignment[];
-}
-export interface TeamsTeammate {
-    name: string;
-    subagent_type: 'general-purpose';
-    team_name: string;
-    prompt: string;
-}
-export interface TeamsDispatch {
-    team_name: string;
-    description: string;
-    teammates: TeamsTeammate[];
-}
-export interface VisibilityMessages {
-    onStart: string;
-    onFinding: string;
-    onComplete: string;
-}
-export interface VisibilityConfig {
-    reportTo: string;
-    format: string;
-    includeProgress: boolean;
-    messages?: VisibilityMessages;
-}
+export type { DispatchParams, DispatchedAgent, InnerTeamsSpec, TaskmaestroAssignment, TaskmaestroDispatch, TeamsTeammate, TeamsDispatch, VisibilityMessages, VisibilityConfig, SubagentLayer, TaskmaestroLayer, TeamsLayer, ExecutionLayer, ExecutionPlan, } from './execution-plan.types';
 export interface DispatchResult {
     primaryAgent?: DispatchedAgent;
     parallelAgents?: DispatchedAgent[];
@@ -84,6 +54,7 @@ export interface DispatchResult {
     teams?: TeamsDispatch;
     executionStrategy?: string;
     visibility?: VisibilityConfig;
+    executionPlan?: ExecutionPlan;
 }
 export interface InlineAgentDefinition {
     name: string;
@@ -100,6 +71,14 @@ export interface InlineAgentDefinition {
     };
     [key: string]: unknown;
 }
+export interface AgentStackSummary {
+    name: string;
+    description: string;
+    category: string;
+    primary_agent: string;
+    specialist_count: number;
+    tags: string[];
+}
 export interface DispatchAgentsInput {
     mode: Mode;
     taskDescription?: string;
@@ -107,7 +86,8 @@ export interface DispatchAgentsInput {
     specialists?: string[];
     includeParallel?: boolean;
     primaryAgent?: string;
-    executionStrategy?: 'subagent' | 'taskmaestro' | 'teams';
+    agentStack?: string;
+    executionStrategy?: 'subagent' | 'taskmaestro' | 'teams' | 'taskmaestro+teams';
     inlineAgents?: Record<string, InlineAgentDefinition>;
 }
 export declare const FILE_PATTERN_SPECIALISTS: Record<string, string[]>;

package/dist/src/agent/council-preset.service.d.ts

@@ -0,0 +1,6 @@
+import type { CouncilPreset } from './council-preset.types';
+export type { CouncilPreset } from './council-preset.types';
+export declare class CouncilPresetService {
+    resolvePreset(mode: string): CouncilPreset | null;
+    listPresets(): CouncilPreset[];
+}

package/dist/src/agent/council-preset.service.js

@@ -0,0 +1,46 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CouncilPresetService = void 0;
+const common_1 = require("@nestjs/common");
+const COUNCIL_PRESETS = {
+    PLAN: {
+        mode: 'PLAN',
+        primary: 'technical-planner',
+        specialists: [
+            'architecture-specialist',
+            'test-strategy-specialist',
+            'code-quality-specialist',
+            'security-specialist',
+        ],
+    },
+    EVAL: {
+        mode: 'EVAL',
+        primary: 'code-reviewer',
+        specialists: ['security-specialist', 'performance-specialist', 'accessibility-specialist'],
+    },
+};
+let CouncilPresetService = class CouncilPresetService {
+    resolvePreset(mode) {
+        const preset = COUNCIL_PRESETS[mode];
+        if (!preset)
+            return null;
+        return { ...preset, specialists: [...preset.specialists] };
+    }
+    listPresets() {
+        return Object.values(COUNCIL_PRESETS).map(p => ({
+            ...p,
+            specialists: [...p.specialists],
+        }));
+    }
+};
+exports.CouncilPresetService = CouncilPresetService;
+exports.CouncilPresetService = CouncilPresetService = __decorate([
+    (0, common_1.Injectable)()
+], CouncilPresetService);
+//# sourceMappingURL=council-preset.service.js.map

package/dist/src/agent/council-preset.types.d.ts

@@ -0,0 +1,6 @@
+export type CouncilMode = 'PLAN' | 'EVAL';
+export interface CouncilPreset {
+    mode: CouncilMode;
+    primary: string;
+    specialists: string[];
+}

package/dist/src/agent/council-preset.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=council-preset.types.js.map

package/dist/src/agent/execution-plan.d.ts

@@ -0,0 +1,8 @@
+import type { ExecutionPlan, ExecutionLayer, DispatchedAgent, TaskmaestroDispatch, TeamsDispatch, VisibilityConfig } from './execution-plan.types';
+export declare function buildSimplePlan(layer: ExecutionLayer): ExecutionPlan;
+export declare function buildNestedPlan(outer: ExecutionLayer, inner: ExecutionLayer): ExecutionPlan;
+export declare function isNestedPlan(plan: ExecutionPlan): boolean;
+export declare function subagentLayer(agents: DispatchedAgent[]): ExecutionLayer;
+export declare function taskmaestroLayer(config: TaskmaestroDispatch): ExecutionLayer;
+export declare function teamsLayer(config: TeamsDispatch, visibility?: VisibilityConfig): ExecutionLayer;
+export declare function serializeExecutionPlan(plan: ExecutionPlan): Record<string, unknown>;

package/dist/src/agent/execution-plan.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSimplePlan = buildSimplePlan;
+exports.buildNestedPlan = buildNestedPlan;
+exports.isNestedPlan = isNestedPlan;
+exports.subagentLayer = subagentLayer;
+exports.taskmaestroLayer = taskmaestroLayer;
+exports.teamsLayer = teamsLayer;
+exports.serializeExecutionPlan = serializeExecutionPlan;
+function buildSimplePlan(layer) {
+    return { outerExecution: layer };
+}
+function buildNestedPlan(outer, inner) {
+    return { outerExecution: outer, innerCoordination: inner };
+}
+function isNestedPlan(plan) {
+    return plan.innerCoordination !== undefined;
+}
+function subagentLayer(agents) {
+    return { type: 'subagent', agents };
+}
+function taskmaestroLayer(config) {
+    return { type: 'taskmaestro', config };
+}
+function teamsLayer(config, visibility) {
+    return { type: 'teams', config, ...(visibility ? { visibility } : {}) };
+}
+function serializeExecutionPlan(plan) {
+    const serialized = {
+        outerExecution: serializeLayer(plan.outerExecution),
+        isNested: isNestedPlan(plan),
+        strategy: plan.innerCoordination
+            ? `${plan.outerExecution.type}+${plan.innerCoordination.type}`
+            : plan.outerExecution.type,
+    };
+    if (plan.innerCoordination) {
+        serialized.innerCoordination = serializeLayer(plan.innerCoordination);
+    }
+    return serialized;
+}
+function serializeLayer(layer) {
+    switch (layer.type) {
+        case 'subagent':
+            return {
+                type: 'subagent',
+                agentCount: layer.agents.length,
+                agents: layer.agents.map(a => ({
+                    name: a.name,
+                    displayName: a.displayName,
+                    description: a.description,
+                })),
+            };
+        case 'taskmaestro':
+            return {
+                type: 'taskmaestro',
+                sessionName: layer.config.sessionName,
+                paneCount: layer.config.paneCount,
+                assignments: layer.config.assignments.map(a => ({
+                    name: a.name,
+                    displayName: a.displayName,
+                })),
+            };
+        case 'teams':
+            return {
+                type: 'teams',
+                teamName: layer.config.team_name,
+                teammateCount: layer.config.teammates.length,
+                teammates: layer.config.teammates.map(t => ({ name: t.name })),
+                ...(layer.visibility ? { visibility: layer.visibility } : {}),
+            };
+    }
+}
+//# sourceMappingURL=execution-plan.js.map

package/dist/src/agent/execution-plan.types.d.ts

@@ -0,0 +1,74 @@
+export interface DispatchParams {
+    subagent_type: 'general-purpose';
+    prompt: string;
+    description: string;
+    run_in_background?: true;
+}
+export interface DispatchedAgent {
+    name: string;
+    displayName: string;
+    description: string;
+    dispatchParams: DispatchParams;
+}
+export interface InnerTeamsSpec {
+    type: 'teams';
+    teamSpec: {
+        team_name: string;
+        description: string;
+    };
+    teammates: Array<{
+        name: string;
+        subagent_type: 'general-purpose';
+    }>;
+}
+export interface TaskmaestroAssignment {
+    name: string;
+    displayName: string;
+    prompt: string;
+    innerCoordination?: InnerTeamsSpec;
+}
+export interface TaskmaestroDispatch {
+    sessionName: string;
+    paneCount: number;
+    assignments: TaskmaestroAssignment[];
+}
+export interface TeamsTeammate {
+    name: string;
+    subagent_type: 'general-purpose';
+    team_name: string;
+    prompt: string;
+}
+export interface TeamsDispatch {
+    team_name: string;
+    description: string;
+    teammates: TeamsTeammate[];
+}
+export interface VisibilityMessages {
+    onStart: string;
+    onFinding: string;
+    onComplete: string;
+}
+export interface VisibilityConfig {
+    reportTo: string;
+    format: string;
+    includeProgress: boolean;
+    messages?: VisibilityMessages;
+}
+export interface SubagentLayer {
+    type: 'subagent';
+    agents: DispatchedAgent[];
+}
+export interface TaskmaestroLayer {
+    type: 'taskmaestro';
+    config: TaskmaestroDispatch;
+}
+export interface TeamsLayer {
+    type: 'teams';
+    config: TeamsDispatch;
+    visibility?: VisibilityConfig;
+}
+export type ExecutionLayer = SubagentLayer | TaskmaestroLayer | TeamsLayer;
+export interface ExecutionPlan {
+    outerExecution: ExecutionLayer;
+    innerCoordination?: ExecutionLayer;
+}

package/dist/src/agent/execution-plan.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=execution-plan.types.js.map

package/dist/src/agent/index.d.ts

@@ -1,4 +1,12 @@
 export * from './agent.module';
 export * from './agent.service';
+export * from './agent-stack.service';
+export * from './council-preset.service';
+export * from './teams-capability.service';
+export * from './teams-capability.types';
 export * from './agent.types';
 export * from './agent-prompt.builder';
+export * from './agent-stack.schema';
+export * from './agent-stack.loader';
+export * from './execution-plan';
+export * from './execution-plan.types';

package/dist/src/agent/index.js

@@ -16,6 +16,14 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./agent.module"), exports);
 __exportStar(require("./agent.service"), exports);
+__exportStar(require("./agent-stack.service"), exports);
+__exportStar(require("./council-preset.service"), exports);
+__exportStar(require("./teams-capability.service"), exports);
+__exportStar(require("./teams-capability.types"), exports);
 __exportStar(require("./agent.types"), exports);
 __exportStar(require("./agent-prompt.builder"), exports);
+__exportStar(require("./agent-stack.schema"), exports);
+__exportStar(require("./agent-stack.loader"), exports);
+__exportStar(require("./execution-plan"), exports);
+__exportStar(require("./execution-plan.types"), exports);
 //# sourceMappingURL=index.js.map

package/dist/src/agent/teams-capability.service.d.ts

@@ -0,0 +1,11 @@
+import { ConfigService } from '../config/config.service';
+import type { TeamsCapabilityStatus } from './teams-capability.types';
+export declare class TeamsCapabilityService {
+    private readonly configService;
+    private readonly logger;
+    constructor(configService: ConfigService);
+    getStatus(): Promise<TeamsCapabilityStatus>;
+    isAvailable(): Promise<boolean>;
+    readEnvFlag(): boolean | undefined;
+    private readConfigFlag;
+}

package/dist/src/agent/teams-capability.service.js

@@ -0,0 +1,74 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var TeamsCapabilityService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TeamsCapabilityService = void 0;
+const common_1 = require("@nestjs/common");
+const config_service_1 = require("../config/config.service");
+let TeamsCapabilityService = TeamsCapabilityService_1 = class TeamsCapabilityService {
+    constructor(configService) {
+        this.configService = configService;
+        this.logger = new common_1.Logger(TeamsCapabilityService_1.name);
+    }
+    async getStatus() {
+        const envValue = this.readEnvFlag();
+        if (envValue !== undefined) {
+            const status = {
+                available: envValue,
+                reason: envValue
+                    ? 'Enabled via CODINGBUDDY_TEAMS_ENABLED environment variable'
+                    : 'Disabled via CODINGBUDDY_TEAMS_ENABLED environment variable',
+                source: 'environment',
+            };
+            this.logger.debug(`Teams capability: ${status.reason}`);
+            return status;
+        }
+        const configValue = await this.readConfigFlag();
+        if (configValue !== undefined) {
+            const status = {
+                available: configValue,
+                reason: configValue
+                    ? 'Enabled via experimental.teamsCoordination config'
+                    : 'Disabled via experimental.teamsCoordination config',
+                source: 'config',
+            };
+            this.logger.debug(`Teams capability: ${status.reason}`);
+            return status;
+        }
+        const status = {
+            available: false,
+            reason: 'Teams coordination is experimental and disabled by default',
+            source: 'default',
+        };
+        this.logger.debug(`Teams capability: ${status.reason}`);
+        return status;
+    }
+    async isAvailable() {
+        const status = await this.getStatus();
+        return status.available;
+    }
+    readEnvFlag() {
+        const raw = process.env.CODINGBUDDY_TEAMS_ENABLED;
+        if (raw === undefined || raw === '')
+            return undefined;
+        return raw === 'true' || raw === '1';
+    }
+    async readConfigFlag() {
+        const settings = await this.configService.getSettings();
+        return settings.experimental?.teamsCoordination ?? undefined;
+    }
+};
+exports.TeamsCapabilityService = TeamsCapabilityService;
+exports.TeamsCapabilityService = TeamsCapabilityService = TeamsCapabilityService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [config_service_1.ConfigService])
+], TeamsCapabilityService);
+//# sourceMappingURL=teams-capability.service.js.map

package/dist/src/agent/teams-capability.types.d.ts

@@ -0,0 +1,6 @@
+export interface TeamsCapabilityStatus {
+    readonly available: boolean;
+    readonly reason: string;
+    readonly source: TeamsCapabilitySource;
+}
+export type TeamsCapabilitySource = 'config' | 'environment' | 'default';

package/dist/src/agent/teams-capability.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=teams-capability.types.js.map

package/dist/src/app.module.js

@@ -16,6 +16,7 @@ const agent_module_1 = require("./agent/agent.module");
 const checklist_module_1 = require("./checklist/checklist.module");
 const context_module_1 = require("./context/context.module");
 const events_module_1 = require("./tui/events/events.module");
+const plugin_module_1 = require("./plugin/plugin.module");
 let AppModule = class AppModule {
 };
 exports.AppModule = AppModule;
@@ -30,6 +31,7 @@ exports.AppModule = AppModule = __decorate([
             checklist_module_1.ChecklistModule,
             context_module_1.ContextModule,
             events_module_1.TuiEventsModule,
+            plugin_module_1.PluginModule,
         ],
     })
 ], AppModule);

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

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
-import type { InitOptions, TuiOptions } from './cli.types';
+import type { InitOptions, TuiOptions, InstallOptions, UninstallOptions, SearchOptions, UpdateOptions, CreatePluginOptions } from './cli.types';
+import type { CompletionOptions } from './completion';
 export interface ParsedArgs {
-    command: 'init' | 'mcp' | 'tui' | 'help' | 'version';
-    options: Partial<InitOptions> & Partial<TuiOptions>;
+    command: 'init' | 'install' | 'plugins' | 'uninstall' | 'search' | 'update' | 'create-plugin' | 'mcp' | 'tui' | 'completion' | 'help' | 'version';
+    options: Partial<InitOptions> & Partial<TuiOptions> & Partial<InstallOptions> & Partial<UninstallOptions> & Partial<SearchOptions> & Partial<UpdateOptions> & Partial<CreatePluginOptions> & Partial<CompletionOptions>;
 }
 export declare function parseArgs(args: string[]): ParsedArgs;
 export declare function printUsage(): void;