codingbuddy 5.2.0 → 5.4.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,13 @@
 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';
+export * from './stack-matcher';

package/dist/src/agent/index.js

@@ -16,6 +16,15 @@ 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);
+__exportStar(require("./stack-matcher"), exports);
 //# sourceMappingURL=index.js.map

package/dist/src/agent/stack-matcher.d.ts

@@ -0,0 +1,13 @@
+export interface StackMatchInput {
+    name: string;
+    category: string;
+    tags: string[];
+    specialist_agents?: string[];
+}
+export interface StackMatchResult {
+    stackName: string;
+    confidence: number;
+    matchedTags: string[];
+    stackBased: true;
+}
+export declare function matchStack(prompt: string, stacks: readonly StackMatchInput[]): StackMatchResult | null;

package/dist/src/agent/stack-matcher.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchStack = matchStack;
+const DOMAIN_KEYWORDS = [
+    { pattern: /\bREST\b/i, tags: ['rest', 'api'] },
+    { pattern: /\bGraphQL\b/i, tags: ['graphql', 'api'] },
+    { pattern: /\bAPI\b/i, tags: ['api'] },
+    { pattern: /\bbackend\b/i, tags: ['backend'] },
+    { pattern: /\bendpoint/i, tags: ['api', 'backend'] },
+    { pattern: /\bcontroller/i, tags: ['api', 'backend'] },
+    { pattern: /\bservice\s+layer/i, tags: ['backend'] },
+    { pattern: /\broute/i, tags: ['api', 'backend'] },
+    { pattern: /\bsecurity\b/i, tags: ['security'] },
+    { pattern: /\baudit\b/i, tags: ['audit', 'security'] },
+    { pattern: /\b(?:vulnerability|vulnerabilities)\b/i, tags: ['vulnerability', 'security'] },
+    { pattern: /\bcompliance\b/i, tags: ['compliance', 'security'] },
+    { pattern: /\bOAuth\b/i, tags: ['security'] },
+    { pattern: /\bJWT\b/i, tags: ['security'] },
+    { pattern: /\b(?:XSS|CSRF)\b/i, tags: ['security', 'vulnerability'] },
+    { pattern: /\bauthenticat/i, tags: ['security'] },
+    { pattern: /\bUI\b/i, tags: ['ui', 'frontend'] },
+    { pattern: /\bUX\b/i, tags: ['ux', 'frontend'] },
+    { pattern: /\baccessibility\b/i, tags: ['accessibility', 'frontend'] },
+    { pattern: /\bSEO\b/i, tags: ['seo', 'frontend'] },
+    { pattern: /\bfrontend\b/i, tags: ['frontend'] },
+    { pattern: /\bETL\b/i, tags: ['etl', 'data'] },
+    { pattern: /\bpipeline\b/i, tags: ['pipeline', 'data'] },
+    { pattern: /\banalytics\b/i, tags: ['analytics', 'data'] },
+    { pattern: /\bdata\s+(warehouse|lake|pipeline|ingestion)/i, tags: ['data', 'pipeline'] },
+    { pattern: /\bmodel\s+(training|inference|deploy)/i, tags: ['model', 'ml'] },
+    { pattern: /\bML\b/i, tags: ['ml'] },
+    { pattern: /\bmachine\s*learning/i, tags: ['ml', 'ai'] },
+    { pattern: /\binference\b/i, tags: ['inference', 'ml'] },
+    { pattern: /\btraining\b/i, tags: ['training', 'ml'] },
+    { pattern: /\bfull[- ]?stack\b/i, tags: ['fullstack'] },
+    { pattern: /보안/i, tags: ['security'] },
+    { pattern: /취약점/i, tags: ['vulnerability', 'security'] },
+    { pattern: /감사/i, tags: ['audit', 'security'] },
+    { pattern: /접근성/i, tags: ['accessibility', 'frontend'] },
+    { pattern: /데이터\s*파이프라인/i, tags: ['data', 'pipeline'] },
+    { pattern: /머신\s*러닝|기계\s*학습/i, tags: ['ml', 'ai'] },
+];
+const MIN_CONFIDENCE = 0.3;
+function matchStack(prompt, stacks) {
+    if (!prompt || stacks.length === 0)
+        return null;
+    const detectedTags = new Set();
+    for (const { pattern, tags } of DOMAIN_KEYWORDS) {
+        if (pattern.test(prompt)) {
+            for (const tag of tags)
+                detectedTags.add(tag);
+        }
+    }
+    if (detectedTags.size === 0)
+        return null;
+    let bestResult = null;
+    for (const stack of stacks) {
+        const matched = [];
+        for (const tag of stack.tags) {
+            if (detectedTags.has(tag))
+                matched.push(tag);
+        }
+        if (matched.length === 0)
+            continue;
+        const tagCoverage = matched.length / stack.tags.length;
+        const detectedCoverage = matched.length / detectedTags.size;
+        const confidence = Math.min((tagCoverage + detectedCoverage) / 2, 1.0);
+        if (confidence < MIN_CONFIDENCE)
+            continue;
+        if (!bestResult || confidence > bestResult.confidence) {
+            bestResult = {
+                stackName: stack.name,
+                confidence,
+                matchedTags: matched,
+                stackBased: true,
+            };
+        }
+    }
+    return bestResult;
+}
+//# sourceMappingURL=stack-matcher.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/cli/cli.d.ts

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
-import type { InitOptions, TuiOptions, InstallOptions, UninstallOptions, SearchOptions, UpdateOptions } 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' | 'install' | 'plugins' | 'uninstall' | 'search' | 'update' | 'mcp' | 'tui' | 'help' | 'version';
-    options: Partial<InitOptions> & Partial<TuiOptions> & Partial<InstallOptions> & Partial<UninstallOptions> & Partial<SearchOptions> & Partial<UpdateOptions>;
+    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;

package/dist/src/cli/cli.js

@@ -61,6 +61,25 @@ function parseArgs(args) {
             options: { ...options, updatePluginName },
         };
     }
+    if (command === 'create-plugin') {
+        const createPluginName = args[1];
+        let createPluginTemplate;
+        const templateIdx = args.indexOf('--template');
+        if (templateIdx !== -1) {
+            createPluginTemplate = args[templateIdx + 1];
+        }
+        return {
+            command: 'create-plugin',
+            options: { ...options, createPluginName, createPluginTemplate },
+        };
+    }
+    if (command === 'completion') {
+        const shell = args[1];
+        return {
+            command: 'completion',
+            options: { ...options, shell },
+        };
+    }
     if (command !== 'init') {
         return { command: 'help', options };
     }
@@ -95,6 +114,8 @@ Usage:
   codingbuddy mcp                      Start MCP server (stdio mode)
   codingbuddy tui                      Monitor agent execution in real-time
   codingbuddy tui --restart            Restart TUI client (fixes blank screen)
+  codingbuddy create-plugin <name>     Scaffold a new plugin project
+  codingbuddy completion <shell>       Generate shell completions (bash, zsh, fish)
   codingbuddy --help                   Show this help
   codingbuddy --version                Show version
 
@@ -114,6 +135,8 @@ Examples:
   codingbuddy update my-plugin         Update a specific plugin
   codingbuddy uninstall my-plugin      Remove a plugin
   codingbuddy uninstall my-plugin -y   Remove without confirmation
+  codingbuddy create-plugin my-plugin   Scaffold minimal plugin
+  codingbuddy create-plugin my-plugin --template full  Scaffold with examples
   codingbuddy mcp                      Start MCP server for AI assistants
 
 Note:
@@ -233,6 +256,37 @@ async function main(args = process.argv.slice(2)) {
             }
             break;
         }
+        case 'create-plugin': {
+            const { runCreatePlugin } = await Promise.resolve().then(() => require('./plugin/create-plugin.command'));
+            if (!options.createPluginName) {
+                process.stderr.write('Error: Missing plugin name. Usage: codingbuddy create-plugin <name> [--template minimal|full]\n');
+                process.exitCode = 1;
+                break;
+            }
+            const template = options.createPluginTemplate === 'full' ? 'full' : 'minimal';
+            const createResult = await runCreatePlugin({
+                name: options.createPluginName,
+                outputDir: process.cwd(),
+                template,
+            });
+            if (!createResult.success) {
+                process.exitCode = 1;
+            }
+            break;
+        }
+        case 'completion': {
+            const { runCompletion } = await Promise.resolve().then(() => require('./completion'));
+            if (!options.shell) {
+                process.stderr.write('Error: Missing shell type. Usage: codingbuddy completion <bash|zsh|fish>\n');
+                process.exitCode = 1;
+                break;
+            }
+            const completionResult = runCompletion({ shell: options.shell });
+            if (!completionResult.success) {
+                process.exitCode = 1;
+            }
+            break;
+        }
         case 'init': {
             const result = await (0, init_1.runInit)(options);
             if (!result.success) {

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

@@ -29,4 +29,8 @@ export interface SearchOptions {
 export interface UpdateOptions {
     updatePluginName?: string;
 }
+export interface CreatePluginOptions {
+    createPluginName?: string;
+    createPluginTemplate?: string;
+}
 export type LogLevel = 'info' | 'success' | 'warn' | 'error';