codingbuddy 5.1.3 → 5.3.0

package/dist/src/mcp/handlers/quality-report.handler.js

@@ -0,0 +1,93 @@
+"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 QualityReportHandler_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QualityReportHandler = void 0;
+const common_1 = require("@nestjs/common");
+const abstract_handler_1 = require("./abstract-handler");
+const quality_report_service_1 = require("../../ship/quality-report.service");
+const response_utils_1 = require("../response.utils");
+const validation_constants_1 = require("../../shared/validation.constants");
+const rule_event_collector_1 = require("../../rules/rule-event-collector");
+let QualityReportHandler = QualityReportHandler_1 = class QualityReportHandler extends abstract_handler_1.AbstractHandler {
+    constructor(qualityReportService, ruleEventCollector) {
+        super();
+        this.qualityReportService = qualityReportService;
+        this.ruleEventCollector = ruleEventCollector;
+        this.logger = new common_1.Logger(QualityReportHandler_1.name);
+    }
+    getHandledTools() {
+        return ['pr_quality_report'];
+    }
+    async handleTool(_toolName, args) {
+        try {
+            const changedFiles = (0, validation_constants_1.extractStringArray)(args, 'changedFiles');
+            if (!changedFiles || changedFiles.length === 0) {
+                return (0, response_utils_1.createJsonResponse)(await this.qualityReportService.generateReport({ changedFiles: [] }));
+            }
+            const timeout = typeof args?.timeout === 'number' && args.timeout > 0 ? args.timeout : 30000;
+            const result = await this.qualityReportService.generateReport({
+                changedFiles,
+                timeout,
+            });
+            try {
+                const domains = result.domains;
+                if (domains?.length) {
+                    const timestamp = new Date().toISOString();
+                    for (const d of domains) {
+                        this.ruleEventCollector.record({
+                            type: 'specialist_dispatched',
+                            timestamp,
+                            domain: d.domain,
+                        });
+                    }
+                }
+            }
+            catch {
+            }
+            return (0, response_utils_1.createJsonResponse)(result);
+        }
+        catch (error) {
+            this.logger.error(`Quality report failed: ${error}`);
+            return (0, response_utils_1.createErrorResponse)(`Quality report failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    getToolDefinitions() {
+        return [
+            {
+                name: 'pr_quality_report',
+                description: 'Run specialist agents on changed files and generate a Quality Report for PR description',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        changedFiles: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'List of changed file paths to analyze',
+                        },
+                        timeout: {
+                            type: 'number',
+                            description: 'Timeout in milliseconds (default: 30000)',
+                        },
+                    },
+                    required: ['changedFiles'],
+                },
+            },
+        ];
+    }
+};
+exports.QualityReportHandler = QualityReportHandler;
+exports.QualityReportHandler = QualityReportHandler = QualityReportHandler_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [quality_report_service_1.QualityReportService,
+        rule_event_collector_1.RuleEventCollector])
+], QualityReportHandler);
+//# sourceMappingURL=quality-report.handler.js.map

package/dist/src/mcp/handlers/resume.handler.d.ts

@@ -0,0 +1,12 @@
+import type { ToolDefinition } from './base.handler';
+import type { ToolResponse } from '../response.utils';
+import { AbstractHandler } from './abstract-handler';
+import { BriefingLoaderService } from '../../context/briefing-loader.service';
+export declare class ResumeHandler extends AbstractHandler {
+    private readonly briefingLoaderService;
+    private readonly logger;
+    constructor(briefingLoaderService: BriefingLoaderService);
+    protected getHandledTools(): string[];
+    protected handleTool(_toolName: string, args: Record<string, unknown> | undefined): Promise<ToolResponse>;
+    getToolDefinitions(): ToolDefinition[];
+}

package/dist/src/mcp/handlers/resume.handler.js

@@ -0,0 +1,63 @@
+"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 ResumeHandler_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResumeHandler = void 0;
+const common_1 = require("@nestjs/common");
+const abstract_handler_1 = require("./abstract-handler");
+const briefing_loader_service_1 = require("../../context/briefing-loader.service");
+const response_utils_1 = require("../response.utils");
+const validation_constants_1 = require("../../shared/validation.constants");
+let ResumeHandler = ResumeHandler_1 = class ResumeHandler extends abstract_handler_1.AbstractHandler {
+    constructor(briefingLoaderService) {
+        super();
+        this.briefingLoaderService = briefingLoaderService;
+        this.logger = new common_1.Logger(ResumeHandler_1.name);
+    }
+    getHandledTools() {
+        return ['resume_session'];
+    }
+    async handleTool(_toolName, args) {
+        try {
+            const briefingPath = (0, validation_constants_1.extractOptionalString)(args, 'briefingPath');
+            const result = await this.briefingLoaderService.restoreContext(briefingPath);
+            return (0, response_utils_1.createJsonResponse)(result);
+        }
+        catch (error) {
+            this.logger.error(`Session resume failed: ${error}`);
+            return (0, response_utils_1.createErrorResponse)(`Session resume failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    getToolDefinitions() {
+        return [
+            {
+                name: 'resume_session',
+                description: 'Load a previous session briefing to restore context and continue work',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        briefingPath: {
+                            type: 'string',
+                            description: 'Path to a specific briefing file. If omitted, loads the most recent briefing from docs/codingbuddy/briefings/',
+                        },
+                    },
+                    required: [],
+                },
+            },
+        ];
+    }
+};
+exports.ResumeHandler = ResumeHandler;
+exports.ResumeHandler = ResumeHandler = ResumeHandler_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [briefing_loader_service_1.BriefingLoaderService])
+], ResumeHandler);
+//# sourceMappingURL=resume.handler.js.map

package/dist/src/mcp/handlers/rule-impact.handler.d.ts

@@ -0,0 +1,23 @@
+import { AbstractHandler } from './abstract-handler';
+import type { ToolDefinition } from './base.handler';
+import type { ToolResponse } from '../response.utils';
+import { RuleInsightsService } from '../../rules/rule-insights.service';
+import { RulesService } from '../../rules/rules.service';
+export declare class RuleImpactHandler extends AbstractHandler {
+    private readonly insightsService;
+    private readonly rulesService;
+    constructor(insightsService: RuleInsightsService, rulesService: RulesService);
+    protected getHandledTools(): string[];
+    protected handleTool(_toolName: string, args: Record<string, unknown> | undefined): Promise<ToolResponse>;
+    getToolDefinitions(): ToolDefinition[];
+    private extractPeriod;
+    private getAllRuleNames;
+    private formatReport;
+    private appendSummary;
+    private appendTopRules;
+    private appendDomainCoverage;
+    private appendUnusedRules;
+    private appendTrends;
+    private appendSuggestions;
+    private inferDomain;
+}

package/dist/src/mcp/handlers/rule-impact.handler.js

@@ -0,0 +1,241 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleImpactHandler = void 0;
+const common_1 = require("@nestjs/common");
+const path_1 = require("path");
+const abstract_handler_1 = require("./abstract-handler");
+const rule_insights_service_1 = require("../../rules/rule-insights.service");
+const rule_tracker_1 = require("../../rules/rule-tracker");
+const rules_service_1 = require("../../rules/rules.service");
+const validation_constants_1 = require("../../shared/validation.constants");
+const DEFAULT_STATS_PATH = (0, path_1.join)(process.cwd(), 'docs', 'codingbuddy', 'rule-stats.json');
+const MINUTES_PER_VIOLATION = 15;
+const MINUTES_PER_CHECK = 5;
+const VALID_PERIODS = new Set(['week', 'month', 'all']);
+let RuleImpactHandler = class RuleImpactHandler extends abstract_handler_1.AbstractHandler {
+    constructor(insightsService, rulesService) {
+        super();
+        this.insightsService = insightsService;
+        this.rulesService = rulesService;
+    }
+    getHandledTools() {
+        return ['get_rule_impact_report'];
+    }
+    async handleTool(_toolName, args) {
+        const statsPath = (0, validation_constants_1.extractOptionalString)(args, 'statsPath') ?? DEFAULT_STATS_PATH;
+        const period = this.extractPeriod(args);
+        let stats = {};
+        try {
+            const tracker = await rule_tracker_1.RuleTracker.fromFile(statsPath);
+            stats = tracker.getStats();
+        }
+        catch {
+        }
+        const allRuleNames = await this.getAllRuleNames();
+        const insights = this.insightsService.generateInsights(stats, allRuleNames);
+        if (insights.summary.totalRulesTracked === 0) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'No data collected yet. Run some sessions to populate stats.',
+                    },
+                ],
+            };
+        }
+        const report = this.formatReport(insights, period);
+        return {
+            content: [{ type: 'text', text: report }],
+        };
+    }
+    getToolDefinitions() {
+        return [
+            {
+                name: 'get_rule_impact_report',
+                description: 'Generate a formatted markdown impact report showing rule effectiveness: top rules by usage, unused rules, domain coverage, estimated time saved, and trend analysis',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        period: {
+                            type: 'string',
+                            description: 'Report period: "week", "month", or "all" (default: "all")',
+                            enum: ['week', 'month', 'all'],
+                        },
+                        statsPath: {
+                            type: 'string',
+                            description: 'Path to rule-stats.json file. Defaults to docs/codingbuddy/rule-stats.json',
+                        },
+                    },
+                    required: [],
+                },
+            },
+        ];
+    }
+    extractPeriod(args) {
+        const raw = (0, validation_constants_1.extractOptionalString)(args, 'period');
+        if (raw && VALID_PERIODS.has(raw))
+            return raw;
+        return 'all';
+    }
+    async getAllRuleNames() {
+        try {
+            const results = await this.rulesService.searchRules('*');
+            return results.map(r => r.file.replace(/^rules\//, '').replace(/\.md$/, ''));
+        }
+        catch {
+            return [];
+        }
+    }
+    formatReport(insights, period) {
+        const lines = [];
+        lines.push('# Rule Impact Report');
+        lines.push('');
+        lines.push(`> Period: **${period}** | Generated: ${new Date(insights.generatedAt).toISOString()}`);
+        lines.push('');
+        this.appendSummary(lines, insights);
+        this.appendTopRules(lines, insights);
+        this.appendDomainCoverage(lines, insights);
+        this.appendUnusedRules(lines, insights);
+        this.appendTrends(lines, insights);
+        this.appendSuggestions(lines, insights);
+        return lines.join('\n');
+    }
+    appendSummary(lines, insights) {
+        const { summary } = insights;
+        const timeSavedMin = summary.totalUsageCount * MINUTES_PER_VIOLATION +
+            summary.totalRulesTracked * MINUTES_PER_CHECK;
+        const timeSavedHours = (timeSavedMin / 60).toFixed(1);
+        lines.push('## Summary');
+        lines.push('');
+        lines.push(`| Metric | Value |`);
+        lines.push(`| --- | --- |`);
+        lines.push(`| Total Rule Applications | ${summary.totalUsageCount} |`);
+        lines.push(`| Rules Tracked | ${summary.totalRulesTracked} |`);
+        lines.push(`| Active Rules (last 7d) | ${summary.activeRules} |`);
+        lines.push(`| Stale Rules (>30d) | ${summary.staleRules} |`);
+        lines.push(`| **Estimated Time Saved** | **~${timeSavedHours} hours** (~${timeSavedMin} min) |`);
+        lines.push('');
+    }
+    appendTopRules(lines, insights) {
+        lines.push('## Top Rules');
+        lines.push('');
+        if (insights.topRules.length === 0) {
+            lines.push('_No rule usage data yet._');
+            lines.push('');
+            return;
+        }
+        lines.push('| Rule | Applications | Classification |');
+        lines.push('| --- | ---: | --- |');
+        for (const rule of insights.topRules) {
+            const badge = rule.classification === 'high'
+                ? '**HIGH**'
+                : rule.classification === 'medium'
+                    ? 'medium'
+                    : 'low';
+            lines.push(`| ${rule.name} | ${rule.count} | ${badge} |`);
+        }
+        lines.push('');
+    }
+    appendDomainCoverage(lines, insights) {
+        lines.push('## Domain Coverage');
+        lines.push('');
+        const domainMap = new Map();
+        for (const rule of insights.topRules) {
+            const domain = this.inferDomain(rule.name);
+            const entry = domainMap.get(domain) ?? { checks: 0, rules: [] };
+            entry.checks += rule.count;
+            entry.rules.push(rule.name);
+            domainMap.set(domain, entry);
+        }
+        if (domainMap.size === 0) {
+            lines.push('_No domain coverage data yet._');
+            lines.push('');
+            return;
+        }
+        lines.push('| Domain | Checks | Rules |');
+        lines.push('| --- | ---: | --- |');
+        const sorted = [...domainMap.entries()].sort((a, b) => b[1].checks - a[1].checks);
+        for (const [domain, data] of sorted) {
+            lines.push(`| ${domain} | ${data.checks} | ${data.rules.join(', ')} |`);
+        }
+        lines.push('');
+    }
+    appendUnusedRules(lines, insights) {
+        lines.push('## Unused Rules');
+        lines.push('');
+        if (insights.unusedRules.length === 0) {
+            lines.push('All rules are actively used.');
+            lines.push('');
+            return;
+        }
+        lines.push(`${insights.unusedRules.length} rule(s) with 0 applications — consider removing or promoting:`);
+        lines.push('');
+        for (const rule of insights.unusedRules) {
+            lines.push(`- \`${rule}\``);
+        }
+        lines.push('');
+    }
+    appendTrends(lines, insights) {
+        lines.push('## Trend');
+        lines.push('');
+        const { trends } = insights;
+        if (trends.recentlyActive.length > 0) {
+            lines.push(`**Recently Active:** ${trends.recentlyActive.join(', ')}`);
+            lines.push('');
+        }
+        if (trends.emerging.length > 0) {
+            lines.push(`**Emerging:** ${trends.emerging.join(', ')}`);
+            lines.push('');
+        }
+        if (trends.declining.length > 0) {
+            lines.push(`**Declining:** ${trends.declining.join(', ')}`);
+            lines.push('');
+        }
+        if (trends.recentlyActive.length === 0 &&
+            trends.emerging.length === 0 &&
+            trends.declining.length === 0) {
+            lines.push('_No trend data available._');
+            lines.push('');
+        }
+    }
+    appendSuggestions(lines, insights) {
+        if (insights.suggestions.length === 0)
+            return;
+        lines.push('## Suggestions');
+        lines.push('');
+        for (const s of insights.suggestions) {
+            lines.push(`- ${s}`);
+        }
+        lines.push('');
+    }
+    inferDomain(ruleName) {
+        const lower = ruleName.toLowerCase();
+        if (lower.includes('security') || lower.includes('auth'))
+            return 'security';
+        if (lower.includes('test') || lower.includes('tdd'))
+            return 'testing';
+        if (lower.includes('perf') || lower.includes('bundle'))
+            return 'performance';
+        if (lower.includes('access') || lower.includes('a11y') || lower.includes('aria'))
+            return 'accessibility';
+        if (lower.includes('seo') || lower.includes('meta'))
+            return 'seo';
+        return 'general';
+    }
+};
+exports.RuleImpactHandler = RuleImpactHandler;
+exports.RuleImpactHandler = RuleImpactHandler = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [rule_insights_service_1.RuleInsightsService,
+        rules_service_1.RulesService])
+], RuleImpactHandler);
+//# sourceMappingURL=rule-impact.handler.js.map

package/dist/src/mcp/handlers/skill.handler.js

@@ -107,7 +107,7 @@ let SkillHandler = class SkillHandler extends abstract_handler_1.AbstractHandler
             return (0, response_utils_1.createErrorResponse)(`Failed to recommend skills: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
-    handleListSkills(args) {
+    async handleListSkills(args) {
         try {
             const options = {};
             if (typeof args?.minPriority === 'number') {
@@ -116,7 +116,7 @@ let SkillHandler = class SkillHandler extends abstract_handler_1.AbstractHandler
             if (typeof args?.maxPriority === 'number') {
                 options.maxPriority = args.maxPriority;
             }
-            const result = this.skillRecommendationService.listSkills(options);
+            const result = await this.skillRecommendationService.listSkills(options);
             return (0, response_utils_1.createJsonResponse)(result);
         }
         catch (error) {

package/dist/src/mcp/mcp.module.js

@@ -22,6 +22,7 @@ const diagnostic_module_1 = require("../diagnostic/diagnostic.module");
 const events_1 = require("../tui/events");
 const pipeline_module_1 = require("../pipeline/pipeline.module");
 const impact_1 = require("../impact");
+const ship_module_1 = require("../ship/ship.module");
 const skill_recommendation_service_1 = require("../skill/skill-recommendation.service");
 const language_service_1 = require("../shared/language.service");
 const model_1 = require("../model");
@@ -44,6 +45,10 @@ const handlers = [
     handlers_1.ImpactHandler,
     handlers_1.PluginValidationHandler,
     handlers_1.ReleaseCheckHandler,
+    handlers_1.QualityReportHandler,
+    handlers_1.BriefingHandler,
+    handlers_1.ResumeHandler,
+    handlers_1.RuleImpactHandler,
 ];
 let McpModule = class McpModule {
 };
@@ -63,6 +68,7 @@ exports.McpModule = McpModule = __decorate([
             events_1.TuiEventsModule,
             pipeline_module_1.PipelineModule,
             impact_1.ImpactModule,
+            ship_module_1.ShipModule,
         ],
         controllers: [mcp_controller_1.McpController],
         providers: [

package/dist/src/plugin/plugin-installer.service.d.ts

@@ -0,0 +1,41 @@
+export interface InstallOptions {
+    source: string;
+    targetRoot: string;
+    force: boolean;
+    version?: string;
+}
+export interface ResolvedSource {
+    source: string;
+    version?: string;
+}
+export interface InstallResult {
+    success: boolean;
+    pluginName?: string;
+    summary?: string;
+    error?: string;
+}
+export interface PluginRecord {
+    name: string;
+    version: string;
+    source: string;
+    installedAt: string;
+    provides: {
+        agents: string[];
+        rules: string[];
+        skills: string[];
+        checklists: string[];
+    };
+}
+export declare class PluginInstallerService {
+    resolveSource(nameOrUrl: string): Promise<ResolvedSource>;
+    private parseNameVersion;
+    resolveGitUrl(source: string): string;
+    install(options: InstallOptions): Promise<InstallResult>;
+    private isCompatible;
+    private compareVersions;
+    private detectConflicts;
+    private copyAssets;
+    private recordInstallation;
+    private cleanup;
+    private fail;
+}