codingbuddy 5.1.2 → 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({
@@ -595,21 +596,21 @@ var require_eventemitter2 = __commonJS({
       function collectTreeEvents(tree, events, root, asArray) {
         var branches = ownKeys(tree);
         var i = branches.length;
-        var branch, branchName, path9;
+        var branch, branchName, path10;
         var hasListeners = tree["_listeners"];
         var isArrayPath;
         while (i-- > 0) {
           branchName = branches[i];
           branch = tree[branchName];
           if (branchName === "_listeners") {
-            path9 = root;
+            path10 = root;
           } else {
-            path9 = root ? root.concat(branchName) : [branchName];
+            path10 = root ? root.concat(branchName) : [branchName];
           }
           isArrayPath = asArray || typeof branchName === "symbol";
-          hasListeners && events.push(isArrayPath ? path9 : path9.join(this.delimiter));
+          hasListeners && events.push(isArrayPath ? path10 : path10.join(this.delimiter));
           if (typeof branch === "object") {
-            collectTreeEvents.call(this, branch, events, path9, isArrayPath);
+            collectTreeEvents.call(this, branch, events, path10, isArrayPath);
           }
         }
         return events;
@@ -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(dirname2, options) {
+function resolveRulesDir(dirname4, options) {
   if (options?.envRulesDir) {
     return options.envRulesDir;
   }
@@ -2374,15 +2381,15 @@ function resolveRulesDir(dirname2, options) {
     return options.packageRulesPath;
   }
   const candidates = [
-    path2.resolve(dirname2, "../../../../packages/rules/.ai-rules"),
-    path2.resolve(dirname2, "../../../packages/rules/.ai-rules"),
-    path2.resolve(dirname2, "../../../../.ai-rules"),
-    path2.resolve(dirname2, "../../../.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 existsSync6 = options?.existsSync;
-  if (existsSync6) {
+  const existsSync8 = options?.existsSync;
+  if (existsSync8) {
     for (const candidate of candidates) {
-      if (existsSync6(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);
 
@@ -4141,6 +4302,10 @@ TuiEventsModule = __decorateClass([
   })
 ], TuiEventsModule);
 
+// src/tui/events/hud-file-bridge.ts
+import * as fs4 from "node:fs";
+import * as path8 from "node:path";
+
 // src/tui/hooks/use-focus-agent.ts
 function selectFocusedAgent(agents, currentFocusId) {
   if (agents.size === 0) return null;
@@ -5429,57 +5594,57 @@ var ColorBuffer = class {
 
 // src/tui/utils/edge-router.ts
 function computeEdgePath(from, to) {
-  const path9 = [];
+  const path10 = [];
   const midX = Math.floor((from.x + to.x) / 2);
   if (from.y === to.y) {
     const dir = to.x > from.x ? 1 : -1;
     for (let x = from.x; x !== to.x; x += dir) {
-      path9.push({ x, y: from.y, char: "\u2500" });
+      path10.push({ x, y: from.y, char: "\u2500" });
     }
-    path9.push({ x: to.x, y: to.y, char: dir > 0 ? "\u25B8" : "\u25C2" });
+    path10.push({ x: to.x, y: to.y, char: dir > 0 ? "\u25B8" : "\u25C2" });
   } else if (from.x === to.x) {
     const dir = to.y > from.y ? 1 : -1;
     for (let y = from.y; y !== to.y; y += dir) {
-      path9.push({ x: from.x, y, char: "\u2502" });
+      path10.push({ x: from.x, y, char: "\u2502" });
     }
-    path9.push({ x: to.x, y: to.y, char: dir > 0 ? "\u25BE" : "\u25B4" });
+    path10.push({ x: to.x, y: to.y, char: dir > 0 ? "\u25BE" : "\u25B4" });
   } else {
     const dirX = midX > from.x ? 1 : midX < from.x ? -1 : 0;
     if (dirX !== 0) {
       for (let x = from.x; x !== midX; x += dirX) {
-        path9.push({ x, y: from.y, char: "\u2500" });
+        path10.push({ x, y: from.y, char: "\u2500" });
       }
     }
     const dirY = to.y > from.y ? 1 : -1;
-    path9.push({
+    path10.push({
       x: midX,
       y: from.y,
       char: dirX >= 0 ? dirY > 0 ? "\u256E" : "\u256F" : dirY > 0 ? "\u256D" : "\u2570"
     });
     for (let y = from.y + dirY; y !== to.y; y += dirY) {
-      path9.push({ x: midX, y, char: "\u2502" });
+      path10.push({ x: midX, y, char: "\u2502" });
     }
     const dirX2 = to.x > midX ? 1 : to.x < midX ? -1 : 0;
-    path9.push({
+    path10.push({
       x: midX,
       y: to.y,
       char: dirY > 0 ? dirX2 >= 0 ? "\u2570" : "\u256F" : dirX2 >= 0 ? "\u256D" : "\u256E"
     });
     if (dirX2 !== 0) {
       for (let x = midX + dirX2; x !== to.x; x += dirX2) {
-        path9.push({ x, y: to.y, char: "\u2500" });
+        path10.push({ x, y: to.y, char: "\u2500" });
       }
     }
     if (to.x !== midX) {
-      path9.push({ x: to.x, y: to.y, char: dirX2 >= 0 ? "\u25B8" : "\u25C2" });
+      path10.push({ x: to.x, y: to.y, char: dirX2 >= 0 ? "\u25B8" : "\u25C2" });
     } else {
-      path9[path9.length - 1].char = dirY > 0 ? "\u25BE" : "\u25B4";
+      path10[path10.length - 1].char = dirY > 0 ? "\u25BE" : "\u25B4";
     }
   }
-  return path9;
+  return path10;
 }
-function computeLabelPosition(path9, label) {
-  const hSegments = path9.filter((p) => p.char === "\u2500");
+function computeLabelPosition(path10, label) {
+  const hSegments = path10.filter((p) => p.char === "\u2500");
   if (hSegments.length < label.length + 2) return null;
   const startIdx = Math.floor((hSegments.length - label.length) / 2);
   return { x: hSegments[startIdx].x, y: hSegments[startIdx].y };
@@ -5750,14 +5915,14 @@ function renderFlowMap(agents, edges, width, height, activeStage = null) {
       x: toPos.x - 1,
       y: toPos.y + Math.floor(toPos.height / 2)
     };
-    const path9 = computeEdgePath(fromPoint, toPoint);
+    const path10 = computeEdgePath(fromPoint, toPoint);
     const edgeDimmed = inactiveIds.has(edge.from) && inactiveIds.has(edge.to);
-    for (const seg of path9) {
+    for (const seg of path10) {
       const isArrow = seg.char === "\u25B8" || seg.char === "\u25C2" || seg.char === "\u25BE" || seg.char === "\u25B4";
       const segStyle = edgeDimmed ? DIMMED_STYLE : isArrow ? EDGE_STYLES.arrow : EDGE_STYLES.path;
       buf.setChar(seg.x, seg.y, seg.char, segStyle);
     }
-    const labelPos = computeLabelPosition(path9, edge.label);
+    const labelPos = computeLabelPosition(path10, edge.label);
     if (labelPos) {
       buf.writeText(
         labelPos.x,
@@ -6747,7 +6912,7 @@ function DashboardApp({
 // src/tui/multi-session-app.tsx
 import React15, { useMemo as useMemo8, useCallback as useCallback2 } from "react";
 import { Box as Box15, useInput } from "ink";
-import * as path8 from "path";
+import * as path9 from "path";
 
 // src/tui/hooks/use-multi-session-state.ts
 import { useState as useState3, useCallback, useEffect as useEffect4, useRef } from "react";
@@ -6972,7 +7137,7 @@ function MultiSessionApp({ manager }) {
       result.push({
         pid,
         index,
-        projectName: path8.basename(sessionState.projectRoot),
+        projectName: path9.basename(sessionState.projectRoot),
         globalState: sessionState.dashboardState.globalState,
         isActive: pid === activeSessionPid
       });