@triedotdev/mcp 1.0.62 → 1.0.63

package/dist/chunk-4YSLDGBL.js

@@ -0,0 +1,674 @@
+import {
+  BackupManager,
+  atomicWriteJSON,
+  safeParseAndValidate
+} from "./chunk-TSHZQKCM.js";
+
+// src/guardian/guardian-state.ts
+import { mkdir, readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { z } from "zod";
+var GoalSchema = z.object({
+  id: z.string(),
+  description: z.string(),
+  type: z.enum(["streak", "reduction", "score", "custom"]),
+  metric: z.string(),
+  target: z.number(),
+  currentValue: z.number(),
+  startValue: z.number().optional(),
+  status: z.enum(["active", "achieved", "failed", "paused", "rejected"]),
+  autoGenerated: z.boolean(),
+  confidence: z.number().min(0).max(1).optional(),
+  // For auto-generated goals
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  achievedAt: z.string().optional(),
+  deadline: z.string().optional(),
+  category: z.enum(["security", "quality", "performance", "coverage", "general"]).optional(),
+  evidence: z.array(z.string()).optional()
+  // Why this goal was generated
+});
+var HypothesisSchema = z.object({
+  id: z.string(),
+  statement: z.string(),
+  confidence: z.number().min(0).max(1),
+  // 0-1, adjusts based on validation
+  status: z.enum(["proposed", "testing", "validated", "invalidated", "retired"]),
+  evidence: z.array(z.object({
+    type: z.enum(["supporting", "contradicting"]),
+    description: z.string(),
+    timestamp: z.string(),
+    weight: z.number().min(0).max(1).optional()
+  })),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  validatedAt: z.string().optional(),
+  testCriteria: z.string().optional(),
+  category: z.enum(["timing", "pattern", "team", "code", "general"]).optional()
+});
+var RiskBudgetSchema = z.object({
+  daily: z.number(),
+  weekly: z.number(),
+  usedToday: z.number(),
+  usedThisWeek: z.number(),
+  lastResetDay: z.string(),
+  // ISO date (YYYY-MM-DD)
+  lastResetWeek: z.string()
+  // ISO week (YYYY-WNN)
+});
+var AgentMetricsSchema = z.object({
+  predictiveAccuracy: z.number().min(0).max(1),
+  falsePositiveRate: z.number().min(0).max(1),
+  userSatisfaction: z.number().min(0).max(1),
+  hypothesisAccuracy: z.number().min(0).max(1),
+  totalPredictions: z.number(),
+  correctPredictions: z.number(),
+  totalInsights: z.number(),
+  helpfulInsights: z.number(),
+  dismissedInsights: z.number(),
+  actedOnInsights: z.number()
+});
+var TimingContextSchema = z.object({
+  quietHoursStart: z.number().min(0).max(23),
+  // Hour of day (0-23)
+  quietHoursEnd: z.number().min(0).max(23),
+  quietHoursEnabled: z.boolean(),
+  workDays: z.array(z.number().min(0).max(6)),
+  // 0 = Sunday
+  lastActiveTimestamp: z.number(),
+  timezone: z.string().optional(),
+  crunchMode: z.boolean(),
+  // During crunch, defer low-priority items
+  crunchModeUntil: z.string().optional()
+});
+var GuardianStateDataSchema = z.object({
+  version: z.literal(1),
+  goals: z.array(GoalSchema),
+  hypotheses: z.array(HypothesisSchema),
+  riskBudget: RiskBudgetSchema,
+  metrics: AgentMetricsSchema,
+  timing: TimingContextSchema,
+  scanFrequencyMs: z.number(),
+  // Current scan frequency
+  lastScanTimestamp: z.number().optional(),
+  lastUpdated: z.string()
+});
+var GuardianState = class {
+  projectPath;
+  data;
+  loaded = false;
+  dirty = false;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.data = this.createDefaultState();
+  }
+  /**
+   * Get the storage file path
+   */
+  getStorePath() {
+    return join(this.projectPath, ".trie", "memory", "guardian-state.json");
+  }
+  /**
+   * Create default state
+   */
+  createDefaultState() {
+    const now = /* @__PURE__ */ new Date();
+    const today = now.toISOString().split("T")[0];
+    const week = this.getISOWeek(now);
+    return {
+      version: 1,
+      goals: [],
+      hypotheses: [],
+      riskBudget: {
+        daily: 10,
+        weekly: 50,
+        usedToday: 0,
+        usedThisWeek: 0,
+        lastResetDay: today,
+        lastResetWeek: week
+      },
+      metrics: {
+        predictiveAccuracy: 0.5,
+        // Start neutral
+        falsePositiveRate: 0.5,
+        userSatisfaction: 0.5,
+        hypothesisAccuracy: 0.5,
+        totalPredictions: 0,
+        correctPredictions: 0,
+        totalInsights: 0,
+        helpfulInsights: 0,
+        dismissedInsights: 0,
+        actedOnInsights: 0
+      },
+      timing: {
+        quietHoursStart: 21,
+        // 9 PM
+        quietHoursEnd: 8,
+        // 8 AM
+        quietHoursEnabled: true,
+        workDays: [1, 2, 3, 4, 5],
+        // Mon-Fri
+        lastActiveTimestamp: Date.now(),
+        crunchMode: false
+      },
+      scanFrequencyMs: 3e5,
+      // 5 minutes default
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Get ISO week string (YYYY-WNN)
+   */
+  getISOWeek(date) {
+    const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+    const dayNum = d.getUTCDay() || 7;
+    d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+    const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+    const weekNo = Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+    return `${d.getUTCFullYear()}-W${weekNo.toString().padStart(2, "0")}`;
+  }
+  /**
+   * Load state from disk
+   */
+  async load() {
+    if (this.loaded) {
+      return this.data;
+    }
+    const storePath = this.getStorePath();
+    try {
+      if (existsSync(storePath)) {
+        const content = await readFile(storePath, "utf-8");
+        const result = safeParseAndValidate(content, GuardianStateDataSchema);
+        if (result.success) {
+          this.data = result.data;
+          this.loaded = true;
+          await this.checkAndResetBudgets();
+          return this.data;
+        }
+        console.error(`   \u26A0\uFE0F Guardian state corrupted: ${result.error}`);
+        const backupManager = new BackupManager(storePath);
+        if (await backupManager.recoverFromBackup()) {
+          console.error("   \u2705 Recovered from backup");
+          const recovered = await readFile(storePath, "utf-8");
+          const recoveredResult = safeParseAndValidate(recovered, GuardianStateDataSchema);
+          if (recoveredResult.success) {
+            this.data = recoveredResult.data;
+            this.loaded = true;
+            return this.data;
+          }
+        }
+        console.error("   \u274C No valid backup found, starting fresh");
+      }
+    } catch (error) {
+      console.error(`   \u26A0\uFE0F Could not load guardian state: ${error}`);
+    }
+    this.data = this.createDefaultState();
+    this.loaded = true;
+    return this.data;
+  }
+  /**
+   * Save state to disk
+   */
+  async save() {
+    if (!this.dirty && this.loaded) {
+      return;
+    }
+    const storePath = this.getStorePath();
+    const memoryDir = join(this.projectPath, ".trie", "memory");
+    await mkdir(memoryDir, { recursive: true });
+    const backupManager = new BackupManager(storePath);
+    await backupManager.createBackup();
+    this.data.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    await atomicWriteJSON(storePath, this.data);
+    this.dirty = false;
+  }
+  /**
+   * Check and reset daily/weekly budgets if needed
+   */
+  async checkAndResetBudgets() {
+    const now = /* @__PURE__ */ new Date();
+    const today = now.toISOString().split("T")[0];
+    const week = this.getISOWeek(now);
+    let needsSave = false;
+    if (this.data.riskBudget.lastResetDay !== today) {
+      this.data.riskBudget.usedToday = 0;
+      this.data.riskBudget.lastResetDay = today;
+      needsSave = true;
+    }
+    if (this.data.riskBudget.lastResetWeek !== week) {
+      this.data.riskBudget.usedThisWeek = 0;
+      this.data.riskBudget.lastResetWeek = week;
+      needsSave = true;
+    }
+    if (needsSave) {
+      this.dirty = true;
+      await this.save();
+    }
+  }
+  // ========================================================================
+  // Goals
+  // ========================================================================
+  /**
+   * Add a goal
+   */
+  async addGoal(goal) {
+    await this.load();
+    if (this.data.goals.some((g) => g.id === goal.id)) {
+      return false;
+    }
+    this.data.goals.push(goal);
+    this.dirty = true;
+    await this.save();
+    return true;
+  }
+  /**
+   * Update a goal
+   */
+  async updateGoal(goalId, updates) {
+    await this.load();
+    const goal = this.data.goals.find((g) => g.id === goalId);
+    if (!goal) {
+      return false;
+    }
+    Object.assign(goal, updates, { updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    this.dirty = true;
+    await this.save();
+    return true;
+  }
+  /**
+   * Get active goals
+   */
+  getActiveGoals() {
+    return this.data.goals.filter((g) => g.status === "active");
+  }
+  /**
+   * Get all goals
+   */
+  getAllGoals() {
+    return [...this.data.goals];
+  }
+  /**
+   * Get goal by ID
+   */
+  getGoal(goalId) {
+    return this.data.goals.find((g) => g.id === goalId);
+  }
+  /**
+   * Remove a goal
+   */
+  async removeGoal(goalId) {
+    await this.load();
+    const index = this.data.goals.findIndex((g) => g.id === goalId);
+    if (index === -1) {
+      return false;
+    }
+    this.data.goals.splice(index, 1);
+    this.dirty = true;
+    await this.save();
+    return true;
+  }
+  /**
+   * Get auto-generated goals
+   */
+  getAutoGeneratedGoals() {
+    return this.data.goals.filter((g) => g.autoGenerated);
+  }
+  /**
+   * Accept or reject an auto-generated goal
+   */
+  async respondToGoal(goalId, accept) {
+    return this.updateGoal(goalId, {
+      status: accept ? "active" : "rejected"
+    });
+  }
+  // ========================================================================
+  // Hypotheses
+  // ========================================================================
+  /**
+   * Add a hypothesis
+   */
+  async addHypothesis(hypothesis) {
+    await this.load();
+    if (this.data.hypotheses.some((h) => h.id === hypothesis.id)) {
+      return false;
+    }
+    this.data.hypotheses.push(hypothesis);
+    this.dirty = true;
+    await this.save();
+    return true;
+  }
+  /**
+   * Update a hypothesis
+   */
+  async updateHypothesis(hypothesisId, updates) {
+    await this.load();
+    const hypothesis = this.data.hypotheses.find((h) => h.id === hypothesisId);
+    if (!hypothesis) {
+      return false;
+    }
+    Object.assign(hypothesis, updates, { updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    this.dirty = true;
+    await this.save();
+    return true;
+  }
+  /**
+   * Add evidence to a hypothesis
+   */
+  async addEvidence(hypothesisId, evidence) {
+    await this.load();
+    const hypothesis = this.data.hypotheses.find((h) => h.id === hypothesisId);
+    if (!hypothesis) {
+      return false;
+    }
+    hypothesis.evidence.push({
+      ...evidence,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    const supportingCount = hypothesis.evidence.filter((e) => e.type === "supporting").length;
+    const contradictingCount = hypothesis.evidence.filter((e) => e.type === "contradicting").length;
+    const total = supportingCount + contradictingCount;
+    if (total > 0) {
+      hypothesis.confidence = supportingCount / total;
+      if (hypothesis.confidence > 0.8 && supportingCount >= 3) {
+        hypothesis.status = "validated";
+        hypothesis.validatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      } else if (hypothesis.confidence < 0.2 && contradictingCount >= 3) {
+        hypothesis.status = "invalidated";
+      }
+    }
+    hypothesis.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.dirty = true;
+    await this.save();
+    return true;
+  }
+  /**
+   * Get active hypotheses
+   */
+  getActiveHypotheses() {
+    return this.data.hypotheses.filter(
+      (h) => h.status === "proposed" || h.status === "testing"
+    );
+  }
+  /**
+   * Get validated hypotheses
+   */
+  getValidatedHypotheses() {
+    return this.data.hypotheses.filter((h) => h.status === "validated");
+  }
+  /**
+   * Get all hypotheses
+   */
+  getAllHypotheses() {
+    return [...this.data.hypotheses];
+  }
+  /**
+   * Get hypothesis by ID
+   */
+  getHypothesis(hypothesisId) {
+    return this.data.hypotheses.find((h) => h.id === hypothesisId);
+  }
+  // ========================================================================
+  // Risk Budget
+  // ========================================================================
+  /**
+   * Get current risk budget
+   */
+  getRiskBudget() {
+    return { ...this.data.riskBudget };
+  }
+  /**
+   * Use risk budget
+   */
+  async useRiskBudget(amount) {
+    await this.load();
+    await this.checkAndResetBudgets();
+    if (this.data.riskBudget.usedToday + amount > this.data.riskBudget.daily) {
+      return false;
+    }
+    if (this.data.riskBudget.usedThisWeek + amount > this.data.riskBudget.weekly) {
+      return false;
+    }
+    this.data.riskBudget.usedToday += amount;
+    this.data.riskBudget.usedThisWeek += amount;
+    this.dirty = true;
+    await this.save();
+    return true;
+  }
+  /**
+   * Check if risk budget is available
+   */
+  hasRiskBudget(amount = 1) {
+    return this.data.riskBudget.usedToday + amount <= this.data.riskBudget.daily && this.data.riskBudget.usedThisWeek + amount <= this.data.riskBudget.weekly;
+  }
+  /**
+   * Update risk budget limits
+   */
+  async setRiskBudget(daily, weekly) {
+    await this.load();
+    this.data.riskBudget.daily = daily;
+    this.data.riskBudget.weekly = weekly;
+    this.dirty = true;
+    await this.save();
+  }
+  // ========================================================================
+  // Metrics
+  // ========================================================================
+  /**
+   * Get agent metrics
+   */
+  getMetrics() {
+    return { ...this.data.metrics };
+  }
+  /**
+   * Record a prediction outcome
+   */
+  async recordPrediction(correct) {
+    await this.load();
+    this.data.metrics.totalPredictions++;
+    if (correct) {
+      this.data.metrics.correctPredictions++;
+    }
+    this.data.metrics.predictiveAccuracy = this.data.metrics.correctPredictions / this.data.metrics.totalPredictions;
+    this.dirty = true;
+    await this.save();
+  }
+  /**
+   * Record user feedback on an insight
+   */
+  async recordInsightFeedback(feedback) {
+    await this.load();
+    this.data.metrics.totalInsights++;
+    switch (feedback) {
+      case "helpful":
+        this.data.metrics.helpfulInsights++;
+        break;
+      case "dismissed":
+        this.data.metrics.dismissedInsights++;
+        break;
+      case "acted":
+        this.data.metrics.actedOnInsights++;
+        this.data.metrics.helpfulInsights++;
+        break;
+    }
+    if (this.data.metrics.totalInsights > 0) {
+      this.data.metrics.userSatisfaction = this.data.metrics.helpfulInsights / this.data.metrics.totalInsights;
+      this.data.metrics.falsePositiveRate = this.data.metrics.dismissedInsights / this.data.metrics.totalInsights;
+    }
+    this.dirty = true;
+    await this.save();
+  }
+  /**
+   * Update hypothesis accuracy
+   */
+  async updateHypothesisAccuracy() {
+    await this.load();
+    const validated = this.data.hypotheses.filter((h) => h.status === "validated").length;
+    const invalidated = this.data.hypotheses.filter((h) => h.status === "invalidated").length;
+    const total = validated + invalidated;
+    if (total > 0) {
+      this.data.metrics.hypothesisAccuracy = validated / total;
+      this.dirty = true;
+      await this.save();
+    }
+  }
+  // ========================================================================
+  // Timing Context
+  // ========================================================================
+  /**
+   * Get timing context
+   */
+  getTimingContext() {
+    return { ...this.data.timing };
+  }
+  /**
+   * Check if currently in quiet hours
+   */
+  isQuietHours() {
+    if (!this.data.timing.quietHoursEnabled) {
+      return false;
+    }
+    const now = /* @__PURE__ */ new Date();
+    const hour = now.getHours();
+    const start = this.data.timing.quietHoursStart;
+    const end = this.data.timing.quietHoursEnd;
+    if (start > end) {
+      return hour >= start || hour < end;
+    }
+    return hour >= start && hour < end;
+  }
+  /**
+   * Check if today is a work day
+   */
+  isWorkDay() {
+    const dayOfWeek = (/* @__PURE__ */ new Date()).getDay();
+    return this.data.timing.workDays.includes(dayOfWeek);
+  }
+  /**
+   * Check if in crunch mode
+   */
+  isInCrunchMode() {
+    if (!this.data.timing.crunchMode) {
+      return false;
+    }
+    if (this.data.timing.crunchModeUntil) {
+      const until = new Date(this.data.timing.crunchModeUntil);
+      if (Date.now() > until.getTime()) {
+        this.data.timing.crunchMode = false;
+        this.data.timing.crunchModeUntil = void 0;
+        this.dirty = true;
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Enable crunch mode
+   */
+  async setCrunchMode(enabled, until) {
+    await this.load();
+    this.data.timing.crunchMode = enabled;
+    this.data.timing.crunchModeUntil = until?.toISOString();
+    this.dirty = true;
+    await this.save();
+  }
+  /**
+   * Update quiet hours settings
+   */
+  async setQuietHours(start, end, enabled = true) {
+    await this.load();
+    this.data.timing.quietHoursStart = start;
+    this.data.timing.quietHoursEnd = end;
+    this.data.timing.quietHoursEnabled = enabled;
+    this.dirty = true;
+    await this.save();
+  }
+  /**
+   * Update work days
+   */
+  async setWorkDays(days) {
+    await this.load();
+    this.data.timing.workDays = days;
+    this.dirty = true;
+    await this.save();
+  }
+  /**
+   * Update last active timestamp
+   */
+  async touchActive() {
+    await this.load();
+    this.data.timing.lastActiveTimestamp = Date.now();
+    this.dirty = true;
+    await this.save();
+  }
+  // ========================================================================
+  // Scan Frequency
+  // ========================================================================
+  /**
+   * Get current scan frequency in milliseconds
+   */
+  getScanFrequencyMs() {
+    return this.data.scanFrequencyMs;
+  }
+  /**
+   * Set scan frequency
+   */
+  async setScanFrequency(ms) {
+    await this.load();
+    this.data.scanFrequencyMs = Math.max(1e4, ms);
+    this.dirty = true;
+    await this.save();
+  }
+  /**
+   * Record a scan timestamp
+   */
+  async recordScan() {
+    await this.load();
+    this.data.lastScanTimestamp = Date.now();
+    this.dirty = true;
+    await this.save();
+  }
+  /**
+   * Get last scan timestamp
+   */
+  getLastScanTimestamp() {
+    return this.data.lastScanTimestamp;
+  }
+  // ========================================================================
+  // Utility
+  // ========================================================================
+  /**
+   * Get full state data
+   */
+  getData() {
+    return { ...this.data };
+  }
+  /**
+   * Force reload from disk
+   */
+  async reload() {
+    this.loaded = false;
+    this.dirty = false;
+    return this.load();
+  }
+  /**
+   * Check if loaded
+   */
+  isLoaded() {
+    return this.loaded;
+  }
+};
+var guardianStates = /* @__PURE__ */ new Map();
+function getGuardianState(projectPath) {
+  let state = guardianStates.get(projectPath);
+  if (!state) {
+    state = new GuardianState(projectPath);
+    guardianStates.set(projectPath, state);
+  }
+  return state;
+}
+
+export {
+  getGuardianState
+};
+//# sourceMappingURL=chunk-4YSLDGBL.js.map