codingbuddy 5.1.3 → 5.2.0

package/dist/src/tui-bundle.mjs

@@ -38,6 +38,7 @@ var __decorateClass = (decorators, target, key, kind) => {
   if (kind && result) __defProp(target, key, result);
   return result;
 };
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
 
 // node_modules/eventemitter2/lib/eventemitter2.js
 var require_eventemitter2 = __commonJS({
@@ -2302,9 +2303,14 @@ var SkillSchemaError = class extends Error {
     this.name = "SkillSchemaError";
   }
 };
+var SkillFrontmatterTriggerSchema = z2.object({
+  pattern: z2.string().min(1),
+  confidence: z2.enum(["high", "medium", "low"])
+});
 var SkillFrontmatterSchema = z2.object({
   name: z2.string().min(1).regex(/^[a-z0-9-]+$/, "Skill name must be lowercase alphanumeric with hyphens only"),
-  description: z2.string().min(1).max(500)
+  description: z2.string().min(1).max(500),
+  triggers: z2.array(SkillFrontmatterTriggerSchema).optional()
 });
 var FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
 function parseFrontmatter(content) {
@@ -2343,7 +2349,8 @@ function parseSkill(content, filePath) {
     name: result.data.name,
     description: result.data.description,
     content: body,
-    path: filePath
+    path: filePath,
+    triggers: result.data.triggers
   };
 }
 
@@ -2366,7 +2373,7 @@ function getReadFile(deps) {
 function getReaddir(deps) {
   return deps?.readdir ?? defaultReaddir;
 }
-function resolveRulesDir(dirname3, options) {
+function resolveRulesDir(dirname4, options) {
   if (options?.envRulesDir) {
     return options.envRulesDir;
   }
@@ -2374,15 +2381,15 @@ function resolveRulesDir(dirname3, options) {
     return options.packageRulesPath;
   }
   const candidates = [
-    path2.resolve(dirname3, "../../../../packages/rules/.ai-rules"),
-    path2.resolve(dirname3, "../../../packages/rules/.ai-rules"),
-    path2.resolve(dirname3, "../../../../.ai-rules"),
-    path2.resolve(dirname3, "../../../.ai-rules")
+    path2.resolve(dirname4, "../../../../packages/rules/.ai-rules"),
+    path2.resolve(dirname4, "../../../packages/rules/.ai-rules"),
+    path2.resolve(dirname4, "../../../../.ai-rules"),
+    path2.resolve(dirname4, "../../../.ai-rules")
   ];
-  const existsSync7 = options?.existsSync;
-  if (existsSync7) {
+  const existsSync8 = options?.existsSync;
+  if (existsSync8) {
     for (const candidate of candidates) {
-      if (existsSync7(candidate)) {
+      if (existsSync8(candidate)) {
         return candidate;
       }
     }
@@ -2394,9 +2401,9 @@ async function readRuleContent(rulesDir, relativePath, deps) {
     throw new Error("Access denied: Invalid path");
   }
   const fullPath = path2.join(rulesDir, relativePath);
-  const readFile3 = getReadFile(deps);
+  const readFile4 = getReadFile(deps);
   try {
-    return await readFile3(fullPath, "utf-8");
+    return await readFile4(fullPath, "utf-8");
   } catch {
     throw new Error(`Failed to read rule file: ${relativePath}`);
   }
@@ -2450,7 +2457,7 @@ async function searchInRuleFiles(rulesDir, query, files, deps) {
 async function listSkillSummaries(rulesDir, deps) {
   const skillsDir = path2.join(rulesDir, "skills");
   const readdir2 = getReaddir(deps);
-  const readFile3 = getReadFile(deps);
+  const readFile4 = getReadFile(deps);
   const summaries = [];
   try {
     const entries = await readdir2(skillsDir, {
@@ -2460,11 +2467,12 @@ async function listSkillSummaries(rulesDir, deps) {
       if (entry.isDirectory()) {
         const skillPath = path2.join(skillsDir, entry.name, "SKILL.md");
         try {
-          const content = await readFile3(skillPath, "utf-8");
+          const content = await readFile4(skillPath, "utf-8");
           const skill = parseSkill(content, `skills/${entry.name}/SKILL.md`);
           summaries.push({
             name: skill.name,
-            description: skill.description
+            description: skill.description,
+            triggers: skill.triggers
           });
         } catch {
         }
@@ -2483,9 +2491,9 @@ async function loadSkill(rulesDir, name, deps) {
     throw new Error("Access denied: Invalid path");
   }
   const fullPath = path2.join(rulesDir, skillPath);
-  const readFile3 = getReadFile(deps);
+  const readFile4 = getReadFile(deps);
   try {
-    const content = await readFile3(fullPath, "utf-8");
+    const content = await readFile4(fullPath, "utf-8");
     return parseSkill(content, skillPath);
   } catch (error) {
     if (error instanceof SkillSchemaError) {
@@ -2629,7 +2637,7 @@ var RulesService = class {
   // ============================================================================
   /**
    * List all available skills from the skills directory
-   * @returns Array of skill summaries with name and description
+   * @returns Array of skill summaries with name, description, and optional triggers
    */
   async listSkillsFromDir() {
     try {
@@ -2761,11 +2769,164 @@ RuleInsightsService = __decorateClass([
   Injectable5()
 ], RuleInsightsService);
 
+// src/rules/rule-event-collector.ts
+import { Injectable as Injectable6 } from "@nestjs/common";
+
+// src/rules/rule-event.types.ts
+var RULE_EVENT_TYPES = [
+  "mode_activated",
+  "checklist_generated",
+  "specialist_dispatched",
+  "violation_caught"
+];
+
+// src/rules/rule-event-collector.ts
+var RuleEventCollector = class {
+  constructor() {
+    this.events = [];
+  }
+  record(event) {
+    if (!RULE_EVENT_TYPES.includes(event.type)) {
+      throw new Error(`Invalid rule event type: ${event.type}`);
+    }
+    this.events.push({
+      ...event,
+      timestamp: event.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  getEvents() {
+    return [...this.events];
+  }
+  flush() {
+    const flushed = [...this.events];
+    this.events = [];
+    return flushed;
+  }
+};
+RuleEventCollector = __decorateClass([
+  Injectable6()
+], RuleEventCollector);
+
+// src/rules/rule-stats-writer.ts
+import { Injectable as Injectable7, Inject, Optional } from "@nestjs/common";
+import { readFile, writeFile, rename, mkdir } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { dirname, join as join2 } from "path";
+var STATS_FILE_PATH = /* @__PURE__ */ Symbol("STATS_FILE_PATH");
+var DEFAULT_STATS_RELATIVE_PATH = "docs/codingbuddy/rule-stats.json";
+function createEmptyStats() {
+  return {
+    lastUpdated: (/* @__PURE__ */ 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: (/* @__PURE__ */ 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;
+}
+var RuleStatsWriter = class {
+  constructor(collector, statsPath) {
+    this.collector = collector;
+    this.statsPath = statsPath ?? join2(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 readFile(this.statsPath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  async atomicWrite(stats) {
+    const dir = dirname(this.statsPath);
+    if (!existsSync2(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+    const tmpPath = this.statsPath + ".tmp";
+    await writeFile(tmpPath, JSON.stringify(stats, null, 2), "utf-8");
+    await rename(tmpPath, this.statsPath);
+  }
+};
+RuleStatsWriter = __decorateClass([
+  Injectable7(),
+  __decorateParam(1, Optional()),
+  __decorateParam(1, Inject(STATS_FILE_PATH))
+], RuleStatsWriter);
+
 // src/custom/custom.module.ts
 import { Module } from "@nestjs/common";
 
 // src/custom/custom.service.ts
-import { Injectable as Injectable6, Logger as Logger5 } from "@nestjs/common";
+import { Injectable as Injectable8, Logger as Logger5 } from "@nestjs/common";
 import * as fs from "fs/promises";
 import * as path3 from "path";
 
@@ -2885,7 +3046,7 @@ var CustomService = class {
   }
 };
 CustomService = __decorateClass([
-  Injectable6()
+  Injectable8()
 ], CustomService);
 
 // src/custom/custom.module.ts
@@ -2902,14 +3063,14 @@ CustomModule = __decorateClass([
 import { Module as Module2 } from "@nestjs/common";
 
 // src/config/config.service.ts
-import { Injectable as Injectable7, Logger as Logger6 } from "@nestjs/common";
-import { existsSync as existsSync5, statSync } from "fs";
+import { Injectable as Injectable9, Logger as Logger6 } from "@nestjs/common";
+import { existsSync as existsSync6, statSync } from "fs";
 import { stat, realpath } from "fs/promises";
 import * as path7 from "path";
 
 // src/config/config.loader.ts
 import * as fs2 from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import * as path4 from "path";
 
 // src/config/config.schema.ts
@@ -3128,7 +3289,7 @@ var ConfigLoadError = class extends Error {
 function findConfigFile(projectRoot) {
   for (const fileName of CONFIG_FILE_NAMES) {
     const filePath = path4.join(projectRoot, fileName);
-    if (existsSync2(filePath)) {
+    if (existsSync3(filePath)) {
       return filePath;
     }
   }
@@ -3138,7 +3299,7 @@ function findDeprecatedConfigFiles(projectRoot) {
   const found = [];
   for (const fileName of DEPRECATED_CONFIG_FILE_NAMES) {
     const filePath = path4.join(projectRoot, fileName);
-    if (existsSync2(filePath)) {
+    if (existsSync3(filePath)) {
       found.push(filePath);
     }
   }
@@ -3195,7 +3356,7 @@ function findProjectRoot(startDir) {
       return currentDir;
     }
     const packageJsonPath = path4.join(currentDir, "package.json");
-    if (existsSync2(packageJsonPath) && firstPackageJsonDir === null) {
+    if (existsSync3(packageJsonPath) && firstPackageJsonDir === null) {
       firstPackageJsonDir = currentDir;
     }
     const parentDir = path4.dirname(currentDir);
@@ -3271,7 +3432,7 @@ async function loadConfig(projectRoot) {
 }
 
 // src/config/ignore.parser.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import * as path5 from "path";
 
 // src/shared/file.utils.ts
@@ -3457,7 +3618,7 @@ function parseIgnoreContent(content) {
 }
 async function loadIgnoreFile(projectRoot) {
   const ignorePath = path5.join(projectRoot, IGNORE_FILE_NAME);
-  if (!existsSync3(ignorePath)) {
+  if (!existsSync4(ignorePath)) {
     return {
       patterns: [],
       source: null
@@ -3547,7 +3708,7 @@ function getDefaultIgnorePatterns() {
 }
 
 // src/config/context.loader.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import * as path6 from "path";
 var CONTEXT_DIR_NAME = ".codingbuddy";
 var KNOWN_SUBDIRS = {
@@ -3614,7 +3775,7 @@ async function loadContextFile(contextDir, relativePath) {
 }
 async function loadContextFiles(projectRoot) {
   const contextDir = path6.join(projectRoot, CONTEXT_DIR_NAME);
-  if (!existsSync4(contextDir)) {
+  if (!existsSync5(contextDir)) {
     return {
       files: [],
       source: null,
@@ -3707,7 +3868,7 @@ var ConfigService = class {
     const envRoot = process.env.CODINGBUDDY_PROJECT_ROOT;
     if (envRoot) {
       const normalizedPath = path7.resolve(envRoot);
-      if (existsSync5(normalizedPath)) {
+      if (existsSync6(normalizedPath)) {
         try {
           const stat2 = statSync(normalizedPath);
           if (stat2.isDirectory()) {
@@ -3930,11 +4091,11 @@ var ConfigService = class {
   }
 };
 ConfigService = __decorateClass([
-  Injectable7()
+  Injectable9()
 ], ConfigService);
 
 // src/config/config-diff.service.ts
-import { Injectable as Injectable8 } from "@nestjs/common";
+import { Injectable as Injectable10 } from "@nestjs/common";
 var ConfigDiffService = class {
   /**
    * Compare project analysis with current config
@@ -4106,7 +4267,7 @@ var ConfigDiffService = class {
   }
 };
 ConfigDiffService = __decorateClass([
-  Injectable8()
+  Injectable10()
 ], ConfigDiffService);
 
 // src/config/config.module.ts
@@ -4125,8 +4286,8 @@ var RulesModule = class {
 RulesModule = __decorateClass([
   Module3({
     imports: [CustomModule, CodingBuddyConfigModule],
-    providers: [RulesService, RuleInsightsService],
-    exports: [RulesService, RuleInsightsService]
+    providers: [RulesService, RuleInsightsService, RuleEventCollector, RuleStatsWriter],
+    exports: [RulesService, RuleInsightsService, RuleEventCollector, RuleStatsWriter]
   })
 ], RulesModule);