codingbuddy 5.1.3 → 5.3.0

package/dist/src/rules/skill.schema.js

@@ -13,12 +13,48 @@ class SkillSchemaError extends Error {
     }
 }
 exports.SkillSchemaError = SkillSchemaError;
+function splitAllowedTools(s) {
+    const result = [];
+    let current = '';
+    let depth = 0;
+    for (const ch of s) {
+        if (ch === '(')
+            depth++;
+        else if (ch === ')')
+            depth--;
+        if (ch === ',' && depth === 0) {
+            const trimmed = current.trim();
+            if (trimmed)
+                result.push(trimmed);
+            current = '';
+        }
+        else {
+            current += ch;
+        }
+    }
+    const trimmed = current.trim();
+    if (trimmed)
+        result.push(trimmed);
+    return result;
+}
+const SkillFrontmatterTriggerSchema = z.object({
+    pattern: z.string().min(1),
+    confidence: z.enum(['high', 'medium', 'low']),
+});
 const SkillFrontmatterSchema = z.object({
     name: z
         .string()
         .min(1)
         .regex(/^[a-z0-9-]+$/, 'Skill name must be lowercase alphanumeric with hyphens only'),
     description: z.string().min(1).max(500),
+    triggers: z.array(SkillFrontmatterTriggerSchema).optional(),
+    'user-invocable': z.boolean().optional(),
+    'disable-model-invocation': z.boolean().optional(),
+    context: z.string().optional(),
+    agent: z.string().optional(),
+    'allowed-tools': z
+        .union([z.array(z.string()), z.string().transform(s => splitAllowedTools(s))])
+        .optional(),
 });
 const FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
 function parseFrontmatter(content) {
@@ -59,6 +95,12 @@ function parseSkill(content, filePath) {
         description: result.data.description,
         content: body,
         path: filePath,
+        triggers: result.data.triggers,
+        userInvocable: result.data['user-invocable'],
+        disableModelInvocation: result.data['disable-model-invocation'],
+        context: result.data.context,
+        agent: result.data.agent,
+        allowedTools: result.data['allowed-tools'],
     };
 }
 //# sourceMappingURL=skill.schema.js.map

package/dist/src/shared/rules-core.d.ts

@@ -1,5 +1,5 @@
 import type { AgentProfile, SearchResult } from '../rules/rules.types';
-import type { Skill } from '../rules/skill.schema';
+import type { Skill, SkillFrontmatterTrigger } from '../rules/skill.schema';
 interface ResolveRulesDirOptions {
     envRulesDir?: string;
     packageRulesPath?: string;
@@ -23,6 +23,12 @@ export declare function searchInRuleFiles(rulesDir: string, query: string, files
 export declare function listSkillSummaries(rulesDir: string, deps?: FileSystemDeps): Promise<Array<{
     name: string;
     description: string;
+    triggers?: SkillFrontmatterTrigger[];
+    userInvocable?: boolean;
+    disableModelInvocation?: boolean;
+    context?: string;
+    agent?: string;
+    allowedTools?: string[];
 }>>;
 export declare function loadSkill(rulesDir: string, name: string, deps?: FileSystemDeps): Promise<Skill>;
 export {};

package/dist/src/shared/rules-core.js

@@ -132,6 +132,12 @@ async function listSkillSummaries(rulesDir, deps) {
                     summaries.push({
                         name: skill.name,
                         description: skill.description,
+                        triggers: skill.triggers,
+                        userInvocable: skill.userInvocable,
+                        disableModelInvocation: skill.disableModelInvocation,
+                        context: skill.context,
+                        agent: skill.agent,
+                        allowedTools: skill.allowedTools,
                     });
                 }
                 catch {

package/dist/src/shared/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "5.1.3";
+export declare const VERSION = "5.3.0";

package/dist/src/shared/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-exports.VERSION = '5.1.3';
+exports.VERSION = '5.3.0';
 //# sourceMappingURL=version.js.map

package/dist/src/ship/file-specialist-mapper.d.ts

@@ -0,0 +1,9 @@
+interface MappedSpecialist {
+    specialist: string;
+    domain: string;
+}
+export declare class FileSpecialistMapper {
+    mapFile(filePath: string): MappedSpecialist[];
+    mapFiles(filePaths: string[]): MappedSpecialist[];
+}
+export {};

package/dist/src/ship/file-specialist-mapper.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSpecialistMapper = void 0;
+const MAPPINGS = [
+    {
+        pattern: /\.(ts|tsx)$/,
+        specialist: 'code-quality-specialist',
+        domain: 'code-quality',
+    },
+    {
+        pattern: /(auth|security|crypto|password|token|jwt)/i,
+        specialist: 'security-specialist',
+        domain: 'security',
+    },
+    {
+        pattern: /\.tsx$/,
+        specialist: 'accessibility-specialist',
+        domain: 'accessibility',
+    },
+    {
+        pattern: /(package\.json|webpack|vite|bundle)/i,
+        specialist: 'performance-specialist',
+        domain: 'performance',
+    },
+];
+class FileSpecialistMapper {
+    mapFile(filePath) {
+        const matched = [];
+        const seen = new Set();
+        for (const mapping of MAPPINGS) {
+            if (mapping.pattern.test(filePath) && !seen.has(mapping.domain)) {
+                seen.add(mapping.domain);
+                matched.push({
+                    specialist: mapping.specialist,
+                    domain: mapping.domain,
+                });
+            }
+        }
+        return matched;
+    }
+    mapFiles(filePaths) {
+        const seen = new Set();
+        const result = [];
+        for (const filePath of filePaths) {
+            for (const mapped of this.mapFile(filePath)) {
+                if (!seen.has(mapped.domain)) {
+                    seen.add(mapped.domain);
+                    result.push(mapped);
+                }
+            }
+        }
+        return result;
+    }
+}
+exports.FileSpecialistMapper = FileSpecialistMapper;
+//# sourceMappingURL=file-specialist-mapper.js.map

package/dist/src/ship/quality-report.service.d.ts

@@ -0,0 +1,6 @@
+import type { QualityReportInput, QualityReportResult } from './quality-report.types';
+export declare class QualityReportService {
+    private readonly mapper;
+    generateReport(input: QualityReportInput): Promise<QualityReportResult>;
+    private formatMarkdown;
+}

package/dist/src/ship/quality-report.service.js

@@ -0,0 +1,56 @@
+"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.QualityReportService = void 0;
+const common_1 = require("@nestjs/common");
+const file_specialist_mapper_1 = require("./file-specialist-mapper");
+let QualityReportService = class QualityReportService {
+    constructor() {
+        this.mapper = new file_specialist_mapper_1.FileSpecialistMapper();
+    }
+    async generateReport(input) {
+        const start = Date.now();
+        const { changedFiles } = input;
+        const mappedSpecialists = this.mapper.mapFiles(changedFiles);
+        const domains = mappedSpecialists.map(mapped => ({
+            domain: mapped.domain,
+            specialist: mapped.specialist,
+            status: 'pass',
+            findings: [],
+        }));
+        const markdown = this.formatMarkdown(domains, changedFiles.length);
+        const duration = Date.now() - start;
+        return { domains, markdown, duration };
+    }
+    formatMarkdown(domains, fileCount) {
+        if (domains.length === 0) {
+            return '# Quality Report\n\nNo changed files to analyze.\n';
+        }
+        const lines = [
+            '# Quality Report',
+            '',
+            `**Files analyzed:** ${fileCount}`,
+            `**Domains detected:** ${domains.length}`,
+            '',
+            '| Domain | Specialist | Status | Findings |',
+            '|--------|-----------|--------|----------|',
+        ];
+        for (const domain of domains) {
+            const statusIcon = domain.status === 'pass' ? 'pass' : domain.status;
+            const findingsText = domain.findings.length > 0 ? domain.findings.join('; ') : 'No issues found';
+            lines.push(`| ${domain.domain} | ${domain.specialist} | ${statusIcon} | ${findingsText} |`);
+        }
+        lines.push('');
+        return lines.join('\n');
+    }
+};
+exports.QualityReportService = QualityReportService;
+exports.QualityReportService = QualityReportService = __decorate([
+    (0, common_1.Injectable)()
+], QualityReportService);
+//# sourceMappingURL=quality-report.service.js.map

package/dist/src/ship/quality-report.types.d.ts

@@ -0,0 +1,20 @@
+export interface FileSpecialistMapping {
+    pattern: RegExp;
+    specialist: string;
+    domain: string;
+}
+export interface QualityReportInput {
+    changedFiles: string[];
+    timeout?: number;
+}
+export interface DomainResult {
+    domain: string;
+    specialist: string;
+    status: 'pass' | 'warning' | 'fail';
+    findings: string[];
+}
+export interface QualityReportResult {
+    domains: DomainResult[];
+    markdown: string;
+    duration: number;
+}

package/dist/src/ship/quality-report.types.js

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

package/dist/src/ship/ship.module.d.ts

@@ -0,0 +1,2 @@
+export declare class ShipModule {
+}

package/dist/src/ship/ship.module.js

@@ -0,0 +1,21 @@
+"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.ShipModule = void 0;
+const common_1 = require("@nestjs/common");
+const quality_report_service_1 = require("./quality-report.service");
+let ShipModule = class ShipModule {
+};
+exports.ShipModule = ShipModule;
+exports.ShipModule = ShipModule = __decorate([
+    (0, common_1.Module)({
+        providers: [quality_report_service_1.QualityReportService],
+        exports: [quality_report_service_1.QualityReportService],
+    })
+], ShipModule);
+//# sourceMappingURL=ship.module.js.map