triagent 0.1.0-alpha8 → 0.1.0-beta2

package/src/storage/investigation-history.ts

@@ -0,0 +1,277 @@
+import { mkdir, readFile, writeFile, readdir, unlink, stat } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import type {
+  InvestigationHistory,
+  HistoryQueryOptions,
+  HistoryStats,
+  InvestigationEvent,
+  ToolCallRecord,
+} from "./types.js";
+
+const HISTORY_DIR = join(homedir(), ".config", "triagent", "history");
+
+export class InvestigationHistoryStore {
+  private historyDir: string;
+  private retentionDays: number;
+
+  constructor(retentionDays: number = 30) {
+    this.historyDir = HISTORY_DIR;
+    this.retentionDays = retentionDays;
+  }
+
+  async init(): Promise<void> {
+    await mkdir(this.historyDir, { recursive: true });
+    await this.cleanupOldRecords();
+  }
+
+  private getFilePath(id: string): string {
+    return join(this.historyDir, `${id}.json`);
+  }
+
+  async save(investigation: InvestigationHistory): Promise<void> {
+    await mkdir(this.historyDir, { recursive: true });
+    const filePath = this.getFilePath(investigation.id);
+    const serialized = JSON.stringify(investigation, (key, value) => {
+      if (value instanceof Date) {
+        return { __type: "Date", value: value.toISOString() };
+      }
+      return value;
+    }, 2);
+    await writeFile(filePath, serialized, "utf-8");
+  }
+
+  async get(id: string): Promise<InvestigationHistory | null> {
+    try {
+      const filePath = this.getFilePath(id);
+      const content = await readFile(filePath, "utf-8");
+      return this.deserialize(content);
+    } catch {
+      return null;
+    }
+  }
+
+  async delete(id: string): Promise<boolean> {
+    try {
+      const filePath = this.getFilePath(id);
+      await unlink(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async list(options: HistoryQueryOptions = {}): Promise<InvestigationHistory[]> {
+    const {
+      limit = 50,
+      offset = 0,
+      status,
+      cluster,
+      tags,
+      startDate,
+      endDate,
+      searchQuery,
+    } = options;
+
+    try {
+      const files = await readdir(this.historyDir);
+      const investigations: InvestigationHistory[] = [];
+
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+
+        const content = await readFile(join(this.historyDir, file), "utf-8");
+        const investigation = this.deserialize(content);
+
+        // Apply filters
+        if (status && investigation.status !== status) continue;
+        if (cluster && investigation.cluster !== cluster) continue;
+        if (tags && tags.length > 0) {
+          const hasAllTags = tags.every((tag) =>
+            investigation.tags?.includes(tag)
+          );
+          if (!hasAllTags) continue;
+        }
+        if (startDate && investigation.startedAt < startDate) continue;
+        if (endDate && investigation.startedAt > endDate) continue;
+        if (searchQuery) {
+          const searchLower = searchQuery.toLowerCase();
+          const matchesTitle = investigation.incident.title
+            .toLowerCase()
+            .includes(searchLower);
+          const matchesDescription = investigation.incident.description
+            .toLowerCase()
+            .includes(searchLower);
+          if (!matchesTitle && !matchesDescription) continue;
+        }
+
+        investigations.push(investigation);
+      }
+
+      // Sort by startedAt descending
+      investigations.sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
+
+      // Apply pagination
+      return investigations.slice(offset, offset + limit);
+    } catch {
+      return [];
+    }
+  }
+
+  async getStats(): Promise<HistoryStats> {
+    const investigations = await this.list({ limit: 10000 });
+    const now = new Date();
+    const oneDayAgo = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+    const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+
+    const stats: HistoryStats = {
+      total: investigations.length,
+      byStatus: {
+        pending: 0,
+        running: 0,
+        completed: 0,
+        failed: 0,
+      },
+      byCluster: {},
+      averageDuration: 0,
+      last24Hours: 0,
+      last7Days: 0,
+    };
+
+    let totalDuration = 0;
+    let completedCount = 0;
+
+    for (const inv of investigations) {
+      stats.byStatus[inv.status]++;
+
+      if (inv.cluster) {
+        stats.byCluster[inv.cluster] = (stats.byCluster[inv.cluster] || 0) + 1;
+      }
+
+      if (inv.startedAt >= oneDayAgo) {
+        stats.last24Hours++;
+      }
+      if (inv.startedAt >= sevenDaysAgo) {
+        stats.last7Days++;
+      }
+
+      if (inv.completedAt && inv.startedAt) {
+        totalDuration += inv.completedAt.getTime() - inv.startedAt.getTime();
+        completedCount++;
+      }
+    }
+
+    if (completedCount > 0) {
+      stats.averageDuration = totalDuration / completedCount;
+    }
+
+    return stats;
+  }
+
+  async addEvent(
+    investigationId: string,
+    event: Omit<InvestigationEvent, "id" | "timestamp">
+  ): Promise<void> {
+    const investigation = await this.get(investigationId);
+    if (!investigation) return;
+
+    const newEvent: InvestigationEvent = {
+      ...event,
+      id: crypto.randomUUID(),
+      timestamp: new Date(),
+    };
+
+    investigation.events.push(newEvent);
+    await this.save(investigation);
+  }
+
+  async addToolCall(
+    investigationId: string,
+    toolCall: Omit<ToolCallRecord, "id" | "timestamp">
+  ): Promise<void> {
+    const investigation = await this.get(investigationId);
+    if (!investigation) return;
+
+    const newToolCall: ToolCallRecord = {
+      ...toolCall,
+      id: crypto.randomUUID(),
+      timestamp: new Date(),
+    };
+
+    investigation.toolCalls.push(newToolCall);
+    await this.save(investigation);
+  }
+
+  async updateStatus(
+    investigationId: string,
+    status: InvestigationHistory["status"],
+    result?: InvestigationHistory["result"],
+    rawResult?: string,
+    error?: string
+  ): Promise<void> {
+    const investigation = await this.get(investigationId);
+    if (!investigation) return;
+
+    investigation.status = status;
+    if (status === "completed" || status === "failed") {
+      investigation.completedAt = new Date();
+    }
+    if (result) {
+      investigation.result = result;
+    }
+    if (rawResult) {
+      investigation.rawResult = rawResult;
+    }
+    if (error) {
+      investigation.error = error;
+    }
+
+    await this.save(investigation);
+  }
+
+  private async cleanupOldRecords(): Promise<void> {
+    try {
+      const files = await readdir(this.historyDir);
+      const cutoffDate = new Date();
+      cutoffDate.setDate(cutoffDate.getDate() - this.retentionDays);
+
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+
+        const filePath = join(this.historyDir, file);
+        const fileStat = await stat(filePath);
+
+        if (fileStat.mtime < cutoffDate) {
+          await unlink(filePath);
+        }
+      }
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+
+  private deserialize(content: string): InvestigationHistory {
+    return JSON.parse(content, (key, value) => {
+      if (value && typeof value === "object" && value.__type === "Date") {
+        return new Date(value.value);
+      }
+      return value;
+    });
+  }
+}
+
+// Singleton instance
+let historyStore: InvestigationHistoryStore | null = null;
+
+export function getHistoryStore(retentionDays?: number): InvestigationHistoryStore {
+  if (!historyStore) {
+    historyStore = new InvestigationHistoryStore(retentionDays);
+  }
+  return historyStore;
+}
+
+export async function initHistoryStore(retentionDays?: number): Promise<InvestigationHistoryStore> {
+  const store = getHistoryStore(retentionDays);
+  await store.init();
+  return store;
+}

package/src/storage/runbook-index.ts

@@ -0,0 +1,330 @@
+import { readFile, writeFile, readdir, stat } from "fs/promises";
+import { homedir } from "os";
+import { join, extname, basename } from "path";
+import type { RunbookEntry, RunbookIndex } from "./types.js";
+
+const INDEX_FILE = join(homedir(), ".config", "triagent", "runbook-index.json");
+
+export class RunbookIndexer {
+  private index: RunbookIndex;
+  private paths: string[];
+
+  constructor(paths: string[] = []) {
+    this.paths = paths;
+    this.index = {
+      entries: [],
+      vocabulary: [],
+      idfValues: {},
+      lastIndexed: new Date(),
+    };
+  }
+
+  async load(): Promise<void> {
+    try {
+      const content = await readFile(INDEX_FILE, "utf-8");
+      this.index = JSON.parse(content, (key, value) => {
+        if (key === "lastIndexed" || key === "lastModified") {
+          return new Date(value);
+        }
+        return value;
+      });
+    } catch {
+      // Index doesn't exist yet
+    }
+  }
+
+  async save(): Promise<void> {
+    await writeFile(INDEX_FILE, JSON.stringify(this.index, null, 2), "utf-8");
+  }
+
+  async indexPaths(paths: string[]): Promise<number> {
+    this.paths = paths;
+    const entries: RunbookEntry[] = [];
+
+    for (const path of paths) {
+      const files = await this.findMarkdownFiles(path);
+      for (const file of files) {
+        const entry = await this.parseRunbook(file);
+        if (entry) {
+          entries.push(entry);
+        }
+      }
+    }
+
+    // Build vocabulary and IDF values
+    this.buildVocabulary(entries);
+
+    // Compute TF-IDF vectors for each entry
+    for (const entry of entries) {
+      entry.tfidfVector = this.computeTfIdf(entry.content);
+    }
+
+    this.index = {
+      entries,
+      vocabulary: this.index.vocabulary,
+      idfValues: this.index.idfValues,
+      lastIndexed: new Date(),
+    };
+
+    await this.save();
+    return entries.length;
+  }
+
+  private async findMarkdownFiles(dirPath: string): Promise<string[]> {
+    const files: string[] = [];
+
+    try {
+      const entries = await readdir(dirPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = join(dirPath, entry.name);
+
+        if (entry.isDirectory() && !entry.name.startsWith(".")) {
+          const subFiles = await this.findMarkdownFiles(fullPath);
+          files.push(...subFiles);
+        } else if (entry.isFile() && [".md", ".markdown"].includes(extname(entry.name).toLowerCase())) {
+          files.push(fullPath);
+        }
+      }
+    } catch {
+      // Directory not accessible
+    }
+
+    return files;
+  }
+
+  private async parseRunbook(filePath: string): Promise<RunbookEntry | null> {
+    try {
+      const content = await readFile(filePath, "utf-8");
+      const fileStat = await stat(filePath);
+
+      // Extract title from first heading or filename
+      const titleMatch = content.match(/^#\s+(.+)$/m);
+      const title = titleMatch ? titleMatch[1] : basename(filePath, extname(filePath));
+
+      // Extract tags from frontmatter or content
+      const tags = this.extractTags(content);
+
+      // Extract symptoms (lines that might describe problems)
+      const symptoms = this.extractSymptoms(content);
+
+      return {
+        id: Buffer.from(filePath).toString("base64"),
+        path: filePath,
+        title,
+        content,
+        tags,
+        symptoms,
+        lastModified: fileStat.mtime,
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  private extractTags(content: string): string[] {
+    const tags: string[] = [];
+
+    // Check for YAML frontmatter tags
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (frontmatterMatch) {
+      const tagsMatch = frontmatterMatch[1].match(/tags:\s*\[([^\]]+)\]/);
+      if (tagsMatch) {
+        tags.push(...tagsMatch[1].split(",").map((t) => t.trim().replace(/['"]/g, "")));
+      }
+    }
+
+    // Extract keywords from headings
+    const headings = content.match(/^#+\s+(.+)$/gm) || [];
+    for (const heading of headings) {
+      const text = heading.replace(/^#+\s+/, "").toLowerCase();
+      if (text.includes("error") || text.includes("issue") || text.includes("problem")) {
+        tags.push("troubleshooting");
+      }
+      if (text.includes("deploy") || text.includes("rollback")) {
+        tags.push("deployment");
+      }
+      if (text.includes("scale") || text.includes("performance")) {
+        tags.push("scaling");
+      }
+    }
+
+    return [...new Set(tags)];
+  }
+
+  private extractSymptoms(content: string): string[] {
+    const symptoms: string[] = [];
+
+    // Look for sections that describe symptoms
+    const lines = content.split("\n");
+    let inSymptomsSection = false;
+
+    for (const line of lines) {
+      const lowerLine = line.toLowerCase();
+
+      // Check if entering a symptoms section
+      if (lowerLine.includes("symptom") || lowerLine.includes("sign") || lowerLine.includes("indicator")) {
+        inSymptomsSection = true;
+        continue;
+      }
+
+      // Check if leaving symptoms section
+      if (inSymptomsSection && line.match(/^#+\s/)) {
+        inSymptomsSection = false;
+      }
+
+      // Collect bullet points in symptoms section
+      if (inSymptomsSection && line.match(/^[-*]\s/)) {
+        symptoms.push(line.replace(/^[-*]\s+/, "").trim());
+      }
+
+      // Also look for error patterns
+      if (lowerLine.includes("error:") || lowerLine.includes("exception:") || lowerLine.includes("failed:")) {
+        symptoms.push(line.trim());
+      }
+    }
+
+    return symptoms.slice(0, 10); // Limit to 10 symptoms
+  }
+
+  private buildVocabulary(entries: RunbookEntry[]): void {
+    const docFrequency = new Map<string, number>();
+    const vocabulary = new Set<string>();
+
+    for (const entry of entries) {
+      const words = this.tokenize(entry.content);
+      const uniqueWords = new Set(words);
+
+      for (const word of uniqueWords) {
+        vocabulary.add(word);
+        docFrequency.set(word, (docFrequency.get(word) || 0) + 1);
+      }
+    }
+
+    this.index.vocabulary = Array.from(vocabulary);
+
+    // Compute IDF values
+    const numDocs = entries.length;
+    for (const [word, df] of docFrequency) {
+      this.index.idfValues[word] = Math.log((numDocs + 1) / (df + 1)) + 1;
+    }
+  }
+
+  private computeTfIdf(content: string): Record<string, number> {
+    const words = this.tokenize(content);
+    const tf = new Map<string, number>();
+
+    for (const word of words) {
+      tf.set(word, (tf.get(word) || 0) + 1);
+    }
+
+    const vector: Record<string, number> = {};
+    const maxTf = Math.max(...tf.values());
+
+    for (const [word, count] of tf) {
+      const normalizedTf = count / maxTf;
+      const idf = this.index.idfValues[word] || 1;
+      vector[word] = normalizedTf * idf;
+    }
+
+    return vector;
+  }
+
+  private tokenize(text: string): string[] {
+    return text
+      .toLowerCase()
+      .replace(/[^a-z0-9\s-]/g, " ")
+      .split(/\s+/)
+      .filter((word) => word.length > 2 && !this.isStopWord(word));
+  }
+
+  private isStopWord(word: string): boolean {
+    const stopWords = new Set([
+      "the", "is", "at", "which", "on", "a", "an", "and", "or", "but",
+      "in", "with", "to", "for", "of", "as", "by", "that", "this",
+      "it", "from", "be", "are", "was", "were", "been", "being",
+      "have", "has", "had", "do", "does", "did", "will", "would",
+      "could", "should", "may", "might", "must", "can", "not", "no",
+      "all", "any", "both", "each", "few", "more", "most", "other",
+      "some", "such", "only", "own", "same", "than", "too", "very",
+    ]);
+    return stopWords.has(word);
+  }
+
+  search(query: string, limit: number = 5): RunbookEntry[] {
+    const queryVector = this.computeTfIdf(query);
+    const scores: Array<{ entry: RunbookEntry; score: number }> = [];
+
+    for (const entry of this.index.entries) {
+      if (!entry.tfidfVector) continue;
+
+      const score = this.cosineSimilarity(queryVector, entry.tfidfVector);
+      if (score > 0) {
+        scores.push({ entry, score });
+      }
+    }
+
+    // Sort by score descending
+    scores.sort((a, b) => b.score - a.score);
+
+    return scores.slice(0, limit).map((s) => s.entry);
+  }
+
+  private cosineSimilarity(a: Record<string, number>, b: Record<string, number>): number {
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+
+    for (const key of Object.keys(a)) {
+      const aVal = a[key] || 0;
+      const bVal = b[key] || 0;
+      dotProduct += aVal * bVal;
+      normA += aVal * aVal;
+    }
+
+    for (const key of Object.keys(b)) {
+      const bVal = b[key] || 0;
+      normB += bVal * bVal;
+    }
+
+    if (normA === 0 || normB === 0) return 0;
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+  }
+
+  searchBySymptoms(symptoms: string[], limit: number = 5): RunbookEntry[] {
+    const query = symptoms.join(" ");
+    return this.search(query, limit);
+  }
+
+  getByTags(tags: string[]): RunbookEntry[] {
+    return this.index.entries.filter((entry) =>
+      tags.some((tag) => entry.tags.includes(tag.toLowerCase()))
+    );
+  }
+
+  getStats(): { totalRunbooks: number; lastIndexed: Date } {
+    return {
+      totalRunbooks: this.index.entries.length,
+      lastIndexed: this.index.lastIndexed,
+    };
+  }
+}
+
+// Singleton instance
+let runbookIndexer: RunbookIndexer | null = null;
+
+export function getRunbookIndexer(): RunbookIndexer {
+  if (!runbookIndexer) {
+    runbookIndexer = new RunbookIndexer();
+  }
+  return runbookIndexer;
+}
+
+export async function initRunbookIndexer(paths?: string[]): Promise<RunbookIndexer> {
+  const indexer = getRunbookIndexer();
+  await indexer.load();
+  if (paths && paths.length > 0) {
+    await indexer.indexPaths(paths);
+  }
+  return indexer;
+}

package/src/storage/types.ts

@@ -0,0 +1,72 @@
+import type { IncidentInput, InvestigationResult } from "../mastra/agents/debugger.js";
+
+export interface InvestigationEvent {
+  id: string;
+  timestamp: Date;
+  type: "tool_call" | "alert" | "k8s_event" | "log_entry" | "user_action";
+  source: string;
+  data: Record<string, unknown>;
+}
+
+export interface InvestigationHistory {
+  id: string;
+  incident: IncidentInput;
+  status: "pending" | "running" | "completed" | "failed";
+  startedAt: Date;
+  completedAt?: Date;
+  result?: InvestigationResult;
+  rawResult?: string;
+  error?: string;
+  cluster?: string;
+  events: InvestigationEvent[];
+  toolCalls: ToolCallRecord[];
+  tags?: string[];
+}
+
+export interface ToolCallRecord {
+  id: string;
+  timestamp: Date;
+  toolName: string;
+  args: Record<string, unknown>;
+  result?: string;
+  duration?: number;
+  error?: string;
+}
+
+export interface HistoryQueryOptions {
+  limit?: number;
+  offset?: number;
+  status?: InvestigationHistory["status"];
+  cluster?: string;
+  tags?: string[];
+  startDate?: Date;
+  endDate?: Date;
+  searchQuery?: string;
+}
+
+export interface HistoryStats {
+  total: number;
+  byStatus: Record<InvestigationHistory["status"], number>;
+  byCluster: Record<string, number>;
+  averageDuration: number;
+  last24Hours: number;
+  last7Days: number;
+}
+
+export interface RunbookEntry {
+  id: string;
+  path: string;
+  title: string;
+  content: string;
+  tags: string[];
+  symptoms: string[];
+  lastModified: Date;
+  tfidfVector?: Record<string, number>;
+}
+
+export interface RunbookIndex {
+  entries: RunbookEntry[];
+  vocabulary: string[];
+  idfValues: Record<string, number>;
+  lastIndexed: Date;
+}