codingbuddy 5.1.3 → 5.3.0

package/dist/src/skill/skill-recommendation.service.d.ts

@@ -1,6 +1,14 @@
+import { type OnModuleInit } from '@nestjs/common';
 import type { RecommendSkillsResult, ListSkillsResult, ListSkillsOptions } from './skill-recommendation.types';
-export declare class SkillRecommendationService {
+import { RulesService } from '../rules/rules.service';
+export declare class SkillRecommendationService implements OnModuleInit {
+    private readonly rulesService;
+    private frontmatterTriggerCache;
+    private skillMetadataCache;
+    constructor(rulesService: RulesService);
+    onModuleInit(): Promise<void>;
+    loadFrontmatterTriggers(): Promise<void>;
     recommendSkills(prompt: string): RecommendSkillsResult;
     private determineConfidence;
-    listSkills(options?: ListSkillsOptions): ListSkillsResult;
+    listSkills(options?: ListSkillsOptions): Promise<ListSkillsResult>;
 }

package/dist/src/skill/skill-recommendation.service.js

@@ -5,16 +5,63 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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.SkillRecommendationService = void 0;
 const common_1 = require("@nestjs/common");
 const skill_triggers_1 = require("./skill-triggers");
 const keywords_1 = require("./i18n/keywords");
+const rules_service_1 = require("../rules/rules.service");
+const DEFAULT_PRIORITY = 0;
+const CONFIDENCE_RANK = {
+    high: 3,
+    medium: 2,
+    low: 1,
+};
 function getSkillDescription(skillName) {
     const skill = keywords_1.SKILL_KEYWORDS.find(s => s.skillName === skillName);
     return skill?.description ?? `Skill: ${skillName}`;
 }
 let SkillRecommendationService = class SkillRecommendationService {
+    constructor(rulesService) {
+        this.rulesService = rulesService;
+        this.frontmatterTriggerCache = new Map();
+        this.skillMetadataCache = new Map();
+    }
+    async onModuleInit() {
+        await this.loadFrontmatterTriggers();
+    }
+    async loadFrontmatterTriggers() {
+        const skills = await this.rulesService.listSkillsFromDir();
+        this.frontmatterTriggerCache.clear();
+        this.skillMetadataCache.clear();
+        for (const skill of skills) {
+            if (skill.userInvocable !== undefined || skill.disableModelInvocation !== undefined) {
+                this.skillMetadataCache.set(skill.name, {
+                    userInvocable: skill.userInvocable,
+                    disableModelInvocation: skill.disableModelInvocation,
+                });
+            }
+            if (skill.triggers && skill.triggers.length > 0) {
+                const compiled = [];
+                for (const t of skill.triggers) {
+                    try {
+                        compiled.push({ pattern: new RegExp(t.pattern, 'i'), confidence: t.confidence });
+                    }
+                    catch {
+                    }
+                }
+                if (compiled.length > 0) {
+                    this.frontmatterTriggerCache.set(skill.name, {
+                        description: skill.description,
+                        triggers: compiled,
+                    });
+                }
+            }
+        }
+    }
     recommendSkills(prompt) {
         const trimmedPrompt = prompt.trim();
         if (trimmedPrompt.length === 0) {
@@ -29,31 +76,72 @@ let SkillRecommendationService = class SkillRecommendationService {
             const matchedPatterns = [];
             for (const pattern of trigger.patterns) {
                 if (pattern.test(trimmedPrompt)) {
-                    const patternSource = pattern.source;
-                    matchedPatterns.push(patternSource);
+                    matchedPatterns.push(pattern.source);
                 }
             }
             if (matchedPatterns.length > 0 && !skillMatches.has(trigger.skillName)) {
                 skillMatches.set(trigger.skillName, {
                     matchedPatterns,
                     priority: trigger.priority,
+                    confidence: this.determineConfidence(matchedPatterns.length),
+                    description: getSkillDescription(trigger.skillName),
                 });
             }
         }
+        for (const [skillName, entry] of this.frontmatterTriggerCache) {
+            const fmMatchedPatterns = [];
+            let bestConfidence = 'low';
+            for (const trigger of entry.triggers) {
+                if (trigger.pattern.test(trimmedPrompt)) {
+                    fmMatchedPatterns.push(trigger.pattern.source);
+                    if ((CONFIDENCE_RANK[trigger.confidence] ?? 0) > (CONFIDENCE_RANK[bestConfidence] ?? 0)) {
+                        bestConfidence = trigger.confidence;
+                    }
+                }
+            }
+            if (fmMatchedPatterns.length > 0) {
+                const existing = skillMatches.get(skillName);
+                if (existing) {
+                    const mergedPatterns = [...new Set([...existing.matchedPatterns, ...fmMatchedPatterns])];
+                    const existingRank = CONFIDENCE_RANK[existing.confidence] ?? 0;
+                    const newRank = CONFIDENCE_RANK[bestConfidence] ?? 0;
+                    existing.matchedPatterns = mergedPatterns;
+                    if (newRank > existingRank) {
+                        existing.confidence = bestConfidence;
+                    }
+                }
+                else {
+                    skillMatches.set(skillName, {
+                        matchedPatterns: fmMatchedPatterns,
+                        priority: 0,
+                        confidence: bestConfidence,
+                        description: entry.description,
+                    });
+                }
+            }
+        }
         const recommendations = [];
-        for (const [skillName, { matchedPatterns }] of skillMatches) {
-            const confidence = this.determineConfidence(matchedPatterns.length);
+        for (const [skillName, match] of skillMatches) {
+            const metadata = this.skillMetadataCache.get(skillName);
+            if (metadata?.userInvocable === false) {
+                continue;
+            }
+            if (metadata?.disableModelInvocation === true) {
+                continue;
+            }
             recommendations.push({
                 skillName,
-                confidence,
-                matchedPatterns,
-                description: getSkillDescription(skillName),
+                confidence: match.confidence,
+                matchedPatterns: match.matchedPatterns,
+                description: match.description,
             });
         }
         recommendations.sort((a, b) => {
             const aPriority = skillMatches.get(a.skillName)?.priority ?? 0;
             const bPriority = skillMatches.get(b.skillName)?.priority ?? 0;
-            return bPriority - aPriority;
+            if (bPriority !== aPriority)
+                return bPriority - aPriority;
+            return (CONFIDENCE_RANK[b.confidence] ?? 0) - (CONFIDENCE_RANK[a.confidence] ?? 0);
         });
         return {
             recommendations,
@@ -66,13 +154,28 @@ let SkillRecommendationService = class SkillRecommendationService {
         }
         return 'medium';
     }
-    listSkills(options) {
-        let skills = keywords_1.SKILL_KEYWORDS.map(skill => ({
-            name: skill.skillName,
-            priority: skill.priority,
-            description: skill.description,
-            concepts: Object.keys(skill.concepts),
-        }));
+    async listSkills(options) {
+        const fsSkills = await this.rulesService.listSkillsFromDir();
+        let skills = fsSkills.map(fsSkill => {
+            const kwEntry = keywords_1.SKILL_KEYWORDS.find(k => k.skillName === fsSkill.name);
+            const info = {
+                name: fsSkill.name,
+                priority: kwEntry?.priority ?? DEFAULT_PRIORITY,
+                description: fsSkill.description,
+                concepts: kwEntry ? Object.keys(kwEntry.concepts) : [],
+            };
+            if (fsSkill.userInvocable !== undefined)
+                info.userInvocable = fsSkill.userInvocable;
+            if (fsSkill.disableModelInvocation !== undefined)
+                info.disableModelInvocation = fsSkill.disableModelInvocation;
+            if (fsSkill.context !== undefined)
+                info.context = fsSkill.context;
+            if (fsSkill.agent !== undefined)
+                info.agent = fsSkill.agent;
+            if (fsSkill.allowedTools !== undefined)
+                info.allowedTools = fsSkill.allowedTools;
+            return info;
+        });
         if (options?.minPriority !== undefined) {
             skills = skills.filter(s => s.priority >= options.minPriority);
         }
@@ -88,6 +191,7 @@ let SkillRecommendationService = class SkillRecommendationService {
 };
 exports.SkillRecommendationService = SkillRecommendationService;
 exports.SkillRecommendationService = SkillRecommendationService = __decorate([
-    (0, common_1.Injectable)()
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [rules_service_1.RulesService])
 ], SkillRecommendationService);
 //# sourceMappingURL=skill-recommendation.service.js.map

package/dist/src/skill/skill-recommendation.types.d.ts

@@ -18,6 +18,11 @@ export interface SkillInfo {
     priority: number;
     description: string;
     concepts: string[];
+    userInvocable?: boolean;
+    disableModelInvocation?: boolean;
+    context?: string;
+    agent?: string;
+    allowedTools?: string[];
 }
 export interface ListSkillsResult {
     skills: SkillInfo[];

package/dist/src/skill/skill.module.js

@@ -9,11 +9,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SkillModule = void 0;
 const common_1 = require("@nestjs/common");
 const skill_recommendation_service_1 = require("./skill-recommendation.service");
+const rules_module_1 = require("../rules/rules.module");
 let SkillModule = class SkillModule {
 };
 exports.SkillModule = SkillModule;
 exports.SkillModule = SkillModule = __decorate([
     (0, common_1.Module)({
+        imports: [rules_module_1.RulesModule],
         providers: [skill_recommendation_service_1.SkillRecommendationService],
         exports: [skill_recommendation_service_1.SkillRecommendationService],
     })

package/dist/src/tui/events/hud-file-bridge.d.ts

@@ -1,14 +1,17 @@
 import type { TuiEventBus } from './event-bus';
 export interface HudFileBridgeOptions {
     debounceMs?: number;
+    pollIntervalMs?: number;
 }
 export declare class HudFileBridge {
     private readonly eventBus;
     private readonly filePath;
     private readonly debounceMs;
+    private readonly pollIntervalMs;
     private watcher;
     private debounceTimer;
     private pollInterval;
+    private lastMtimeMs;
     private prev;
     private stopped;
     constructor(eventBus: TuiEventBus, filePath: string, options?: HudFileBridgeOptions);
@@ -17,5 +20,6 @@ export declare class HudFileBridge {
     private scheduleProcess;
     private processChange;
     private readState;
+    private startPollingFallback;
     private pollUntilExists;
 }

package/dist/src/tui/events/hud-file-bridge.js

@@ -10,11 +10,13 @@ class HudFileBridge {
         this.watcher = null;
         this.debounceTimer = null;
         this.pollInterval = null;
+        this.lastMtimeMs = 0;
         this.prev = { currentMode: null, activeAgent: null };
         this.stopped = false;
         this.eventBus = eventBus;
         this.filePath = filePath;
         this.debounceMs = options?.debounceMs ?? 150;
+        this.pollIntervalMs = options?.pollIntervalMs ?? 200;
     }
     start() {
         this.stopped = false;
@@ -28,7 +30,11 @@ class HudFileBridge {
                     this.scheduleProcess();
             });
             this.watcher.on('error', () => {
+                this.watcher?.close();
+                this.watcher = null;
+                process.stderr.write('[codingbuddy] fs.watch failed, polling safety net active\n');
             });
+            this.startPollingFallback(true);
         }
         catch {
             this.pollUntilExists();
@@ -91,6 +97,36 @@ class HudFileBridge {
             return { currentMode: null, activeAgent: null };
         }
     }
+    startPollingFallback(silent = false) {
+        if (this.stopped || this.pollInterval)
+            return;
+        if (!silent) {
+            process.stderr.write('[codingbuddy] fs.watch failed, falling back to polling\n');
+        }
+        try {
+            const stat = fs.statSync(this.filePath);
+            this.lastMtimeMs = stat.mtimeMs;
+        }
+        catch {
+            this.lastMtimeMs = 0;
+        }
+        this.pollInterval = setInterval(() => {
+            if (this.stopped) {
+                clearInterval(this.pollInterval);
+                this.pollInterval = null;
+                return;
+            }
+            try {
+                const stat = fs.statSync(this.filePath);
+                if (stat.mtimeMs !== this.lastMtimeMs) {
+                    this.lastMtimeMs = stat.mtimeMs;
+                    this.scheduleProcess();
+                }
+            }
+            catch {
+            }
+        }, this.pollIntervalMs);
+    }
     pollUntilExists() {
         if (this.stopped)
             return;

package/dist/src/tui/testing/tui-test-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function flushInk(cycles?: number): Promise<void>;
+export declare function waitForFrame(getFrame: () => string | undefined, assertion: (frame: string) => void, timeoutMs?: number): Promise<void>;

package/dist/src/tui/testing/tui-test-utils.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flushInk = flushInk;
+exports.waitForFrame = waitForFrame;
+async function flushInk(cycles = 3) {
+    for (let i = 0; i < cycles; i++) {
+        await new Promise(resolve => setTimeout(resolve, 0));
+    }
+}
+async function waitForFrame(getFrame, assertion, timeoutMs = 500) {
+    const start = Date.now();
+    let lastError;
+    while (Date.now() - start < timeoutMs) {
+        try {
+            assertion(getFrame() ?? '');
+            return;
+        }
+        catch (err) {
+            lastError = err;
+            await new Promise(resolve => setTimeout(resolve, 10));
+        }
+    }
+    throw lastError ?? new Error('waitForFrame timeout');
+}
+//# sourceMappingURL=tui-test-utils.js.map