codingbuddy 5.1.3 → 5.3.0

package/dist/src/plugin/plugin-installer.service.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginInstallerService = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const plugin_manifest_schema_1 = require("./plugin-manifest.schema");
+const registry_client_1 = require("./registry-client");
+const version_utils_1 = require("../shared/version.utils");
+const ASSET_DIRS = ['agents', 'rules', 'skills', 'checklists'];
+class PluginInstallerService {
+    async resolveSource(nameOrUrl) {
+        if (nameOrUrl.startsWith('github:') || nameOrUrl.startsWith('https://')) {
+            return { source: nameOrUrl };
+        }
+        const { name, version } = this.parseNameVersion(nameOrUrl);
+        const client = new registry_client_1.RegistryClient();
+        const plugin = await client.findByName(name);
+        if (!plugin) {
+            throw new Error(`Plugin "${name}" not found in registry. Use a git URL (github:user/repo or https://...) for unregistered plugins.`);
+        }
+        return version ? { source: plugin.source, version } : { source: plugin.source };
+    }
+    parseNameVersion(input) {
+        const atIndex = input.lastIndexOf('@');
+        if (atIndex > 0) {
+            return { name: input.slice(0, atIndex), version: input.slice(atIndex + 1) };
+        }
+        return { name: input };
+    }
+    resolveGitUrl(source) {
+        if (source.startsWith('github:')) {
+            const path = source.slice('github:'.length);
+            return `https://github.com/${path}.git`;
+        }
+        if (source.startsWith('https://')) {
+            return source;
+        }
+        throw new Error(`Invalid git URL format: "${source}". Use github:user/repo or https://...`);
+    }
+    async install(options) {
+        let tempDir;
+        try {
+            const gitUrl = this.resolveGitUrl(options.source);
+            tempDir = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'codingbuddy-plugin-'));
+            try {
+                const branchFlag = options.version ? ` --branch v${options.version}` : '';
+                (0, child_process_1.execSync)(`git clone --depth=1${branchFlag} ${gitUrl} ${tempDir}`, {
+                    stdio: 'pipe',
+                    timeout: 60_000,
+                });
+            }
+            catch {
+                return this.fail('Failed to clone repository. Check the URL and your network connection.', tempDir);
+            }
+            const manifestPath = (0, path_1.join)(tempDir, 'plugin.json');
+            if (!(0, fs_1.existsSync)(manifestPath)) {
+                return this.fail('plugin.json not found in repository root.', tempDir);
+            }
+            let manifest;
+            try {
+                const raw = (0, fs_1.readFileSync)(manifestPath, 'utf-8');
+                manifest = (0, plugin_manifest_schema_1.validatePluginManifest)(JSON.parse(raw));
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return this.fail(message, tempDir);
+            }
+            if (manifest.compatibility) {
+                if (!this.isCompatible(manifest.compatibility)) {
+                    return this.fail(`Plugin "${manifest.name}" requires codingbuddy ${manifest.compatibility} but current version is ${(0, version_utils_1.getPackageVersion)()}. Version incompatible.`, tempDir);
+                }
+            }
+            const aiRulesDir = (0, path_1.join)(options.targetRoot, '.ai-rules');
+            if (!options.force) {
+                const conflicts = this.detectConflicts(tempDir, aiRulesDir, manifest);
+                if (conflicts.length > 0) {
+                    return this.fail(`Name conflict detected: ${conflicts.join(', ')}. Use --force to overwrite.`, tempDir);
+                }
+            }
+            const provides = this.copyAssets(tempDir, aiRulesDir);
+            const pluginsJsonPath = (0, path_1.join)(options.targetRoot, '.codingbuddy', 'plugins.json');
+            this.recordInstallation(pluginsJsonPath, {
+                name: manifest.name,
+                version: manifest.version,
+                source: options.source,
+                installedAt: new Date().toISOString(),
+                provides,
+            });
+            const summary = `Installed ${manifest.name}@${manifest.version}: ${provides.agents.length} agents, ${provides.rules.length} rules, ${provides.skills.length} skills`;
+            this.cleanup(tempDir);
+            return { success: true, pluginName: manifest.name, summary };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return this.fail(message, tempDir);
+        }
+    }
+    isCompatible(compatibility) {
+        const currentVersion = (0, version_utils_1.getPackageVersion)();
+        const match = compatibility.match(/^>=(\d+\.\d+\.\d+)$/);
+        if (!match)
+            return true;
+        const required = match[1];
+        return this.compareVersions(currentVersion, required) >= 0;
+    }
+    compareVersions(a, b) {
+        const partsA = a.split('.').map(Number);
+        const partsB = b.split('.').map(Number);
+        for (let i = 0; i < 3; i++) {
+            const diff = (partsA[i] ?? 0) - (partsB[i] ?? 0);
+            if (diff !== 0)
+                return diff;
+        }
+        return 0;
+    }
+    detectConflicts(tempDir, aiRulesDir, manifest) {
+        const conflicts = [];
+        for (const dir of ASSET_DIRS) {
+            const providedNames = manifest.provides[dir] ?? [];
+            for (const name of providedNames) {
+                const extensions = dir === 'agents' ? ['.json'] : ['.md', '.json', '.yaml', '.yml'];
+                for (const ext of extensions) {
+                    const targetPath = (0, path_1.join)(aiRulesDir, dir, `${name}${ext}`);
+                    if ((0, fs_1.existsSync)(targetPath)) {
+                        conflicts.push(`${dir}/${name}`);
+                        break;
+                    }
+                }
+            }
+        }
+        return conflicts;
+    }
+    copyAssets(tempDir, aiRulesDir) {
+        const provides = { agents: [], rules: [], skills: [], checklists: [] };
+        for (const dir of ASSET_DIRS) {
+            const sourceDir = (0, path_1.join)(tempDir, dir);
+            const targetDir = (0, path_1.join)(aiRulesDir, dir);
+            if (!(0, fs_1.existsSync)(sourceDir))
+                continue;
+            (0, fs_1.mkdirSync)(targetDir, { recursive: true });
+            const files = (0, fs_1.readdirSync)(sourceDir);
+            for (const file of files) {
+                (0, fs_1.cpSync)((0, path_1.join)(sourceDir, file), (0, path_1.join)(targetDir, file), { recursive: true });
+                const name = file.replace(/\.[^.]+$/, '');
+                provides[dir].push(name);
+            }
+        }
+        return provides;
+    }
+    recordInstallation(pluginsJsonPath, record) {
+        let registry = { plugins: [] };
+        if ((0, fs_1.existsSync)(pluginsJsonPath)) {
+            try {
+                registry = JSON.parse((0, fs_1.readFileSync)(pluginsJsonPath, 'utf-8'));
+            }
+            catch {
+                registry = { plugins: [] };
+            }
+        }
+        registry.plugins = registry.plugins.filter(p => p.name !== record.name);
+        registry.plugins.push(record);
+        const dir = pluginsJsonPath.replace(/[/\\][^/\\]+$/, '');
+        (0, fs_1.mkdirSync)(dir, { recursive: true });
+        (0, fs_1.writeFileSync)(pluginsJsonPath, JSON.stringify(registry, null, 2), 'utf-8');
+    }
+    cleanup(tempDir) {
+        if (tempDir) {
+            try {
+                (0, fs_1.rmSync)(tempDir, { recursive: true, force: true });
+            }
+            catch {
+            }
+        }
+    }
+    fail(error, tempDir) {
+        this.cleanup(tempDir);
+        return { success: false, error };
+    }
+}
+exports.PluginInstallerService = PluginInstallerService;
+//# sourceMappingURL=plugin-installer.service.js.map

package/dist/src/plugin/plugin-manifest.schema.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export declare class PluginManifestSchemaError extends Error {
+    readonly details?: z.ZodError | undefined;
+    constructor(message: string, details?: z.ZodError | undefined);
+}
+export declare const PluginManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodString;
+    author: z.ZodString;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    compatibility: z.ZodOptional<z.ZodString>;
+    provides: z.ZodObject<{
+        agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        rules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        checklists: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type PluginManifest = z.infer<typeof PluginManifestSchema>;
+export declare function validatePluginManifest(json: unknown): PluginManifest;

package/dist/src/plugin/plugin-manifest.schema.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginManifestSchema = exports.PluginManifestSchemaError = void 0;
+exports.validatePluginManifest = validatePluginManifest;
+const zod_1 = require("zod");
+class PluginManifestSchemaError extends Error {
+    constructor(message, details) {
+        super(message);
+        this.details = details;
+        this.name = 'PluginManifestSchemaError';
+    }
+}
+exports.PluginManifestSchemaError = PluginManifestSchemaError;
+const PluginProvidesSchema = zod_1.z.object({
+    agents: zod_1.z.array(zod_1.z.string()).optional(),
+    rules: zod_1.z.array(zod_1.z.string()).optional(),
+    skills: zod_1.z.array(zod_1.z.string()).optional(),
+    checklists: zod_1.z.array(zod_1.z.string()).optional(),
+});
+exports.PluginManifestSchema = zod_1.z.object({
+    name: zod_1.z
+        .string()
+        .min(1)
+        .regex(/^[a-z][a-z0-9-]*$/, 'Plugin name must start with a letter and contain only lowercase alphanumeric with hyphens'),
+    version: zod_1.z.string().regex(/^\d+\.\d+\.\d+$/, 'Version must be in semver format (e.g. 1.0.0)'),
+    description: zod_1.z.string().min(1),
+    author: zod_1.z.string().min(1),
+    tags: zod_1.z.array(zod_1.z.string()).optional(),
+    compatibility: zod_1.z.string().optional(),
+    provides: PluginProvidesSchema,
+});
+function validatePluginManifest(json) {
+    const result = exports.PluginManifestSchema.safeParse(json);
+    if (result.success) {
+        return result.data;
+    }
+    const errorMessage = result.error.issues
+        .map(issue => {
+        const pathStr = issue.path.length > 0 ? issue.path.join('.') : 'root';
+        return `${pathStr}: ${issue.message}`;
+    })
+        .join(', ');
+    throw new PluginManifestSchemaError(`Invalid plugin manifest: ${errorMessage}`, result.error);
+}
+//# sourceMappingURL=plugin-manifest.schema.js.map

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

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

package/dist/src/plugin/plugin.module.js

@@ -0,0 +1,17 @@
+"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.PluginModule = void 0;
+const common_1 = require("@nestjs/common");
+let PluginModule = class PluginModule {
+};
+exports.PluginModule = PluginModule;
+exports.PluginModule = PluginModule = __decorate([
+    (0, common_1.Module)({})
+], PluginModule);
+//# sourceMappingURL=plugin.module.js.map

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

@@ -0,0 +1,7 @@
+export interface PluginProvides {
+    agents?: string[];
+    rules?: string[];
+    skills?: string[];
+    checklists?: string[];
+}
+export type { PluginManifest } from './plugin-manifest.schema';

package/dist/src/plugin/plugin.types.js

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

package/dist/src/plugin/registry-client.d.ts

@@ -0,0 +1,24 @@
+export interface RegistryPluginProvides {
+    agents?: string[];
+    rules?: string[];
+    skills?: string[];
+    checklists?: string[];
+}
+export interface RegistryPlugin {
+    name: string;
+    version: string;
+    description: string;
+    source: string;
+    tags: string[];
+    provides: RegistryPluginProvides;
+}
+export interface RegistryIndex {
+    plugins: RegistryPlugin[];
+}
+export declare class RegistryClient {
+    private cache;
+    private cacheTime;
+    fetchIndex(): Promise<RegistryIndex>;
+    findByName(name: string): Promise<RegistryPlugin | undefined>;
+    search(query: string): Promise<RegistryPlugin[]>;
+}

package/dist/src/plugin/registry-client.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistryClient = void 0;
+const REGISTRY_URL = 'https://raw.githubusercontent.com/JeremyDev87/codingbuddy-registry/main/index.json';
+const CACHE_TTL_MS = 5 * 60 * 1000;
+class RegistryClient {
+    constructor() {
+        this.cache = null;
+        this.cacheTime = 0;
+    }
+    async fetchIndex() {
+        if (this.cache && Date.now() - this.cacheTime < CACHE_TTL_MS) {
+            return this.cache;
+        }
+        try {
+            const response = await fetch(REGISTRY_URL);
+            if (!response.ok) {
+                return { plugins: [] };
+            }
+            const data = (await response.json());
+            this.cache = data;
+            this.cacheTime = Date.now();
+            return data;
+        }
+        catch {
+            return { plugins: [] };
+        }
+    }
+    async findByName(name) {
+        const index = await this.fetchIndex();
+        return index.plugins.find(plugin => plugin.name === name);
+    }
+    async search(query) {
+        const index = await this.fetchIndex();
+        const lowerQuery = query.toLowerCase();
+        return index.plugins.filter(plugin => {
+            const nameMatch = plugin.name.toLowerCase().includes(lowerQuery);
+            const descMatch = plugin.description.toLowerCase().includes(lowerQuery);
+            const tagMatch = plugin.tags.some(tag => tag.toLowerCase().includes(lowerQuery));
+            return nameMatch || descMatch || tagMatch;
+        });
+    }
+}
+exports.RegistryClient = RegistryClient;
+//# sourceMappingURL=registry-client.js.map

package/dist/src/rules/rule-event-collector.d.ts

@@ -0,0 +1,7 @@
+import { RuleEvent } from './rule-event.types';
+export declare class RuleEventCollector {
+    private events;
+    record(event: RuleEvent): void;
+    getEvents(): RuleEvent[];
+    flush(): RuleEvent[];
+}

package/dist/src/rules/rule-event-collector.js

@@ -0,0 +1,38 @@
+"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.RuleEventCollector = void 0;
+const common_1 = require("@nestjs/common");
+const rule_event_types_1 = require("./rule-event.types");
+let RuleEventCollector = class RuleEventCollector {
+    constructor() {
+        this.events = [];
+    }
+    record(event) {
+        if (!rule_event_types_1.RULE_EVENT_TYPES.includes(event.type)) {
+            throw new Error(`Invalid rule event type: ${event.type}`);
+        }
+        this.events.push({
+            ...event,
+            timestamp: event.timestamp ?? new Date().toISOString(),
+        });
+    }
+    getEvents() {
+        return [...this.events];
+    }
+    flush() {
+        const flushed = [...this.events];
+        this.events = [];
+        return flushed;
+    }
+};
+exports.RuleEventCollector = RuleEventCollector;
+exports.RuleEventCollector = RuleEventCollector = __decorate([
+    (0, common_1.Injectable)()
+], RuleEventCollector);
+//# sourceMappingURL=rule-event-collector.js.map

package/dist/src/rules/rule-event.types.d.ts

@@ -0,0 +1,9 @@
+export declare const RULE_EVENT_TYPES: readonly ["mode_activated", "checklist_generated", "specialist_dispatched", "violation_caught"];
+export type RuleEventType = (typeof RULE_EVENT_TYPES)[number];
+export interface RuleEvent {
+    type: RuleEventType;
+    timestamp: string;
+    domain?: string;
+    rule?: string;
+    details?: Record<string, unknown>;
+}

package/dist/src/rules/rule-event.types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_EVENT_TYPES = void 0;
+exports.RULE_EVENT_TYPES = [
+    'mode_activated',
+    'checklist_generated',
+    'specialist_dispatched',
+    'violation_caught',
+];
+//# sourceMappingURL=rule-event.types.js.map

package/dist/src/rules/rule-stats-writer.d.ts

@@ -0,0 +1,23 @@
+import { RuleEventCollector } from './rule-event-collector';
+export declare const STATS_FILE_PATH: unique symbol;
+export interface RuleStatsEntry {
+    applied: number;
+    sessions: number;
+}
+export interface DomainStatsEntry {
+    checks: number;
+    issues_prevented: number;
+}
+export interface StatsFile {
+    lastUpdated: string;
+    rules: Record<string, RuleStatsEntry>;
+    domains: Record<string, DomainStatsEntry>;
+}
+export declare class RuleStatsWriter {
+    private readonly collector;
+    private readonly statsPath;
+    constructor(collector: RuleEventCollector, statsPath?: string);
+    flush(): Promise<void>;
+    private readExistingStats;
+    private atomicWrite;
+}

package/dist/src/rules/rule-stats-writer.js

@@ -0,0 +1,138 @@
+"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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleStatsWriter = exports.STATS_FILE_PATH = void 0;
+const common_1 = require("@nestjs/common");
+const promises_1 = require("fs/promises");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const rule_event_collector_1 = require("./rule-event-collector");
+exports.STATS_FILE_PATH = Symbol('STATS_FILE_PATH');
+const DEFAULT_STATS_RELATIVE_PATH = 'docs/codingbuddy/rule-stats.json';
+function createEmptyStats() {
+    return {
+        lastUpdated: new Date().toISOString(),
+        rules: {},
+        domains: {},
+    };
+}
+function aggregateEvents(events) {
+    const stats = createEmptyStats();
+    for (const event of events) {
+        switch (event.type) {
+            case 'mode_activated': {
+                if (!event.rule)
+                    break;
+                if (!stats.rules[event.rule]) {
+                    stats.rules[event.rule] = { applied: 0, sessions: 0 };
+                }
+                stats.rules[event.rule].applied += 1;
+                stats.rules[event.rule].sessions += 1;
+                break;
+            }
+            case 'checklist_generated':
+            case 'specialist_dispatched': {
+                if (!event.domain)
+                    break;
+                if (!stats.domains[event.domain]) {
+                    stats.domains[event.domain] = { checks: 0, issues_prevented: 0 };
+                }
+                stats.domains[event.domain].checks += 1;
+                break;
+            }
+            case 'violation_caught': {
+                if (!event.domain)
+                    break;
+                if (!stats.domains[event.domain]) {
+                    stats.domains[event.domain] = { checks: 0, issues_prevented: 0 };
+                }
+                stats.domains[event.domain].issues_prevented += 1;
+                break;
+            }
+        }
+    }
+    return stats;
+}
+function mergeStats(existing, incoming) {
+    const merged = {
+        lastUpdated: new Date().toISOString(),
+        rules: { ...existing.rules },
+        domains: { ...existing.domains },
+    };
+    for (const [name, entry] of Object.entries(incoming.rules)) {
+        if (merged.rules[name]) {
+            merged.rules[name] = {
+                applied: merged.rules[name].applied + entry.applied,
+                sessions: merged.rules[name].sessions + entry.sessions,
+            };
+        }
+        else {
+            merged.rules[name] = { ...entry };
+        }
+    }
+    for (const [name, entry] of Object.entries(incoming.domains)) {
+        if (merged.domains[name]) {
+            merged.domains[name] = {
+                checks: merged.domains[name].checks + entry.checks,
+                issues_prevented: merged.domains[name].issues_prevented + entry.issues_prevented,
+            };
+        }
+        else {
+            merged.domains[name] = { ...entry };
+        }
+    }
+    return merged;
+}
+let RuleStatsWriter = class RuleStatsWriter {
+    constructor(collector, statsPath) {
+        this.collector = collector;
+        this.statsPath = statsPath ?? (0, path_1.join)(process.cwd(), DEFAULT_STATS_RELATIVE_PATH);
+    }
+    async flush() {
+        const events = this.collector.flush();
+        if (events.length === 0) {
+            return;
+        }
+        const incoming = aggregateEvents(events);
+        const existing = await this.readExistingStats();
+        const merged = existing ? mergeStats(existing, incoming) : incoming;
+        await this.atomicWrite(merged);
+    }
+    async readExistingStats() {
+        try {
+            const raw = await (0, promises_1.readFile)(this.statsPath, 'utf-8');
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    async atomicWrite(stats) {
+        const dir = (0, path_1.dirname)(this.statsPath);
+        if (!(0, fs_1.existsSync)(dir)) {
+            await (0, promises_1.mkdir)(dir, { recursive: true });
+        }
+        const tmpPath = this.statsPath + '.tmp';
+        await (0, promises_1.writeFile)(tmpPath, JSON.stringify(stats, null, 2), 'utf-8');
+        await (0, promises_1.rename)(tmpPath, this.statsPath);
+    }
+};
+exports.RuleStatsWriter = RuleStatsWriter;
+exports.RuleStatsWriter = RuleStatsWriter = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Optional)()),
+    __param(1, (0, common_1.Inject)(exports.STATS_FILE_PATH)),
+    __metadata("design:paramtypes", [rule_event_collector_1.RuleEventCollector, String])
+], RuleStatsWriter);
+//# sourceMappingURL=rule-stats-writer.js.map

package/dist/src/rules/rules.module.js

@@ -10,6 +10,8 @@ exports.RulesModule = void 0;
 const common_1 = require("@nestjs/common");
 const rules_service_1 = require("./rules.service");
 const rule_insights_service_1 = require("./rule-insights.service");
+const rule_event_collector_1 = require("./rule-event-collector");
+const rule_stats_writer_1 = require("./rule-stats-writer");
 const custom_1 = require("../custom");
 const config_module_1 = require("../config/config.module");
 let RulesModule = class RulesModule {
@@ -18,8 +20,8 @@ exports.RulesModule = RulesModule;
 exports.RulesModule = RulesModule = __decorate([
     (0, common_1.Module)({
         imports: [custom_1.CustomModule, config_module_1.CodingBuddyConfigModule],
-        providers: [rules_service_1.RulesService, rule_insights_service_1.RuleInsightsService],
-        exports: [rules_service_1.RulesService, rule_insights_service_1.RuleInsightsService],
+        providers: [rules_service_1.RulesService, rule_insights_service_1.RuleInsightsService, rule_event_collector_1.RuleEventCollector, rule_stats_writer_1.RuleStatsWriter],
+        exports: [rules_service_1.RulesService, rule_insights_service_1.RuleInsightsService, rule_event_collector_1.RuleEventCollector, rule_stats_writer_1.RuleStatsWriter],
     })
 ], RulesModule);
 //# sourceMappingURL=rules.module.js.map

package/dist/src/rules/rules.service.d.ts

@@ -1,5 +1,5 @@
 import { AgentProfile, SearchResult } from './rules.types';
-import type { Skill } from './skill.schema';
+import type { Skill, SkillFrontmatterTrigger } from './skill.schema';
 import { CustomService } from '../custom';
 import { ConfigService } from '../config/config.service';
 export declare class RulesService {
@@ -11,12 +11,19 @@ export declare class RulesService {
     getRuleContent(relativePath: string): Promise<string>;
     listAgents(): Promise<string[]>;
     private sortAgentsByPriority;
+    getRulesDir(): string;
     isModeAgent(agentName: string): boolean;
     getAgent(name: string): Promise<AgentProfile>;
     searchRules(query: string): Promise<SearchResult[]>;
     listSkillsFromDir(): Promise<Array<{
         name: string;
         description: string;
+        triggers?: SkillFrontmatterTrigger[];
+        userInvocable?: boolean;
+        disableModelInvocation?: boolean;
+        context?: string;
+        agent?: string;
+        allowedTools?: string[];
     }>>;
     getSkill(name: string): Promise<Skill>;
 }

package/dist/src/rules/rules.service.js

@@ -82,6 +82,9 @@ let RulesService = RulesService_1 = class RulesService {
         const sortedModeAgents = keyword_types_1.MODE_AGENTS.filter(agent => foundModeAgents.includes(agent));
         return [...sortedModeAgents, ...otherAgents.sort()];
     }
+    getRulesDir() {
+        return this.rulesDir;
+    }
     isModeAgent(agentName) {
         return keyword_types_1.MODE_AGENTS.includes(agentName);
     }

package/dist/src/rules/skill.schema.d.ts

@@ -3,10 +3,20 @@ export declare class SkillSchemaError extends Error {
     readonly details?: z.ZodError | undefined;
     constructor(message: string, details?: z.ZodError | undefined);
 }
+export interface SkillFrontmatterTrigger {
+    pattern: string;
+    confidence: 'high' | 'medium' | 'low';
+}
 export interface Skill {
     name: string;
     description: string;
     content: string;
     path: string;
+    triggers?: SkillFrontmatterTrigger[];
+    userInvocable?: boolean;
+    disableModelInvocation?: boolean;
+    context?: string;
+    agent?: string;
+    allowedTools?: string[];
 }
 export declare function parseSkill(content: string, filePath: string): Skill;