@yugenlab/vaayu 0.1.0

package/chunks/chunk-H76V36OF.js

@@ -0,0 +1,1029 @@
+import {
+  EmbeddingService,
+  cosineSimilarity,
+  fallbackEmbedding
+} from "./chunk-JAWZ7ANC.js";
+import {
+  SessionError,
+  getChitraguptaHome
+} from "./chunk-KC6NRZ7U.js";
+
+// ../chitragupta/packages/smriti/src/day-consolidation.ts
+import fs from "fs";
+import path from "path";
+
+// ../chitragupta/packages/smriti/src/event-extractor.ts
+var DOMAIN_SIGNALS = {
+  planning: [
+    /\b(?:plan for|roadmap|milestone|timeline|schedule|deadline|sprint|backlog|prioriti[sz]e)\b/i,
+    /\b(?:next steps|action items|todo list|to-do list|project plan|gantt|kanban)\b/i,
+    /\b(?:due date|estimated time|target date|delivery date|eta for)\b/i
+  ],
+  learning: [
+    /\b(?:teach me|learn about|learn how|tutorial|take a course|study for)\b/i,
+    /\b(?:explain to me|help me understand|walkthrough|lesson on)\b/i,
+    /\b(?:what is a|what are the|concept of|fundamentals of|theory behind)\b/i
+  ],
+  creative: [
+    /\b(?:write a|draft a|compose a|brainstorm|ideate|creative writing|story about|poem|essay|blog post)\b/i,
+    /\b(?:sketch a|mockup|wireframe|logo for|brand identity)\b/i,
+    /\b(?:name suggestions|tagline|slogan|elevator pitch)\b/i
+  ],
+  operational: [
+    /\b(?:deploy to|release to|rollback|rollout|uptime|downtime|incident)\b/i,
+    /\b(?:docker|kubernetes|k8s|nginx|systemd|terraform|ansible)\b/i,
+    /\b(?:infrastructure|ci\/cd pipeline|staging|production environment)\b/i
+  ],
+  research: [
+    /\b(?:research on|investigate|deep dive|literature review|state of the art|sota)\b/i,
+    /\b(?:arxiv|paper on|survey of|systematic review|meta-analysis)\b/i,
+    /\b(?:pros and cons|tradeoffs? between|trade-offs? between|compare .+ vs)\b/i
+  ],
+  health: [
+    /\b(?:health|wellness|fitness|exercise routine|workout|diet plan|nutrition|calories)\b/i,
+    /\b(?:sleep schedule|meditation|mindfulness|mental health|therapy session)\b/i,
+    /\b(?:doctor appointment|symptoms of|medicine|prescription|blood pressure)\b/i
+  ],
+  social: [
+    /\b(?:send a message|reply to|draft an email|write an email|schedule a meeting)\b/i,
+    /\b(?:birthday|anniversary|gift for|party for|event planning|gathering)\b/i,
+    /\b(?:my friend|my family|my colleague|my partner|my wife|my husband)\b/i
+  ],
+  finance: [
+    /\b(?:budget for|monthly expenses|income|salary|payment for|invoice)\b/i,
+    /\b(?:invest in|stock|portfolio|crypto|savings account|retirement|tax return)\b/i,
+    /\b(?:how much does|subscription|billing|net worth|financial)\b/i
+  ],
+  reflection: [
+    /\b(?:reflect on|journal entry|diary entry|retrospective|look back on)\b/i,
+    /\b(?:what went well|what could improve|lessons learned|takeaways from)\b/i,
+    /\b(?:grateful for|gratitude|how am i doing|self-assessment)\b/i
+  ],
+  security: [
+    /\b(?:security audit|vulnerability|exploit|threat model|attack vector|data breach)\b/i,
+    /\b(?:encrypt|decrypt|ssl certificate|tls|oauth|authentication flow)\b/i,
+    /\b(?:access control|firewall rule|security compliance|penetration test|pentest)\b/i
+  ]
+};
+var DOMAIN_EXTRACTOR_MAP = {
+  planning: "discussion",
+  learning: "discussion",
+  creative: "discussion",
+  operational: "mixed",
+  research: "discussion",
+  health: "personal",
+  social: "personal",
+  finance: "personal",
+  reflection: "discussion",
+  security: "mixed"
+};
+function scoreDomainSignals(turns) {
+  const scores = /* @__PURE__ */ new Map();
+  const userContent = turns.filter((t) => t.role === "user").map((t) => t.content).join(" ");
+  for (const [domain, patterns] of Object.entries(DOMAIN_SIGNALS)) {
+    let groupsMatched = 0;
+    for (const pattern of patterns) {
+      if (new RegExp(pattern.source, "i").test(userContent)) {
+        groupsMatched++;
+      }
+    }
+    if (groupsMatched > 0) scores.set(domain, groupsMatched);
+  }
+  return scores;
+}
+function detectSessionType(turns) {
+  if (turns.length === 0) return "personal";
+  let toolTurns = 0;
+  let textTurns = 0;
+  let totalUserLength = 0;
+  let userTurnCount = 0;
+  for (const turn of turns) {
+    const hasToolCall = /\[tool:\w+\]/.test(turn.content) || turn.toolCalls && turn.toolCalls.length > 0;
+    if (hasToolCall) {
+      toolTurns++;
+    } else {
+      textTurns++;
+    }
+    if (turn.role === "user") {
+      totalUserLength += turn.content.length;
+      userTurnCount++;
+    }
+  }
+  const avgUserLength = userTurnCount > 0 ? totalUserLength / userTurnCount : 0;
+  const toolRatio = turns.length > 0 ? toolTurns / turns.length : 0;
+  let coreType;
+  if (turns.length <= 4 && avgUserLength < 100) {
+    coreType = "personal";
+  } else if (toolRatio > 0.6) {
+    coreType = "coding";
+  } else if (toolRatio < 0.15) {
+    coreType = "discussion";
+  } else {
+    coreType = "mixed";
+  }
+  if (coreType === "coding") return "coding";
+  const domainScores = scoreDomainSignals(turns);
+  if (domainScores.size === 0) return coreType;
+  let topDomain = null;
+  let topScore = 0;
+  for (const [domain, score] of domainScores) {
+    if (score > topScore) {
+      topScore = score;
+      topDomain = domain;
+    }
+  }
+  if (topDomain && topScore >= 2) {
+    return topDomain;
+  }
+  return coreType;
+}
+function getExtractorStrategy(sessionType) {
+  if (sessionType === "coding" || sessionType === "discussion" || sessionType === "mixed" || sessionType === "personal") {
+    return sessionType;
+  }
+  return DOMAIN_EXTRACTOR_MAP[sessionType];
+}
+function extractEventChain(meta, turns) {
+  const sessionType = detectSessionType(turns);
+  const provider = meta.provider ?? meta.metadata?.provider ?? meta.agent ?? "unknown";
+  const events = [];
+  const topics = [];
+  const strategy = getExtractorStrategy(sessionType);
+  for (let i = 0; i < turns.length; i++) {
+    const turn = turns[i];
+    const timestamp = turn.createdAt;
+    if (turn.role === "user") {
+      const userEvents = extractFromUserTurn(turn, timestamp, meta.id, provider);
+      events.push(...userEvents);
+      const topic = extractTopic(turn.content);
+      if (topic && !topics.includes(topic)) {
+        topics.push(topic);
+      }
+    } else if (turn.role === "assistant") {
+      switch (strategy) {
+        case "coding":
+          events.push(...extractFromCodingAssistant(turn, timestamp, meta.id, provider));
+          break;
+        case "discussion":
+          events.push(...extractFromDiscussionAssistant(turn, timestamp, meta.id, provider));
+          break;
+        case "mixed":
+          events.push(...extractFromCodingAssistant(turn, timestamp, meta.id, provider));
+          events.push(...extractFromDiscussionAssistant(turn, timestamp, meta.id, provider));
+          break;
+        case "personal":
+          if (turn.content.length < 500) {
+            events.push({
+              type: "action",
+              summary: turn.content.split("\n")[0].slice(0, 200),
+              timestamp,
+              sessionId: meta.id,
+              provider,
+              turnNumber: turn.turnNumber
+            });
+          }
+          break;
+      }
+    }
+  }
+  const deduped = deduplicateEvents(events);
+  deduped.sort((a, b) => a.timestamp - b.timestamp);
+  const narrative = generateNarrative(sessionType, deduped, meta, provider);
+  return { sessionType, events: deduped, narrative, topics, meta };
+}
+function extractFromUserTurn(turn, timestamp, sessionId, provider) {
+  const events = [];
+  const content = turn.content.trim();
+  const toolMatch = content.match(/\[tool:(\w+)\]\s*(.*)/s);
+  if (toolMatch) {
+    events.push({
+      type: "action",
+      summary: `Used ${toolMatch[1]}`,
+      timestamp,
+      sessionId,
+      provider,
+      tool: toolMatch[1],
+      turnNumber: turn.turnNumber
+    });
+    return events;
+  }
+  const factPatterns = [
+    { pattern: /(?:i live in|i'm from|i am from|based in)\s+(.+)/i, type: "fact" },
+    { pattern: /(?:my name is|i'm called|call me)\s+(.+)/i, type: "fact" },
+    { pattern: /(?:i work at|i work for|my company)\s+(.+)/i, type: "fact" },
+    { pattern: /(?:always use|never use|i prefer|i use)\s+(.+)/i, type: "preference" },
+    { pattern: /(?:remember that|don't forget|note that)\s+(.+)/i, type: "fact" }
+  ];
+  for (const { pattern, type } of factPatterns) {
+    const match = content.match(pattern);
+    if (match) {
+      events.push({
+        type,
+        summary: match[0].trim().slice(0, 200),
+        timestamp,
+        sessionId,
+        provider,
+        turnNumber: turn.turnNumber
+      });
+    }
+  }
+  if (content.endsWith("?") || /^(how|what|why|where|when|can|do|is|should)\b/i.test(content)) {
+    events.push({
+      type: "question",
+      summary: content.split("\n")[0].slice(0, 200),
+      timestamp,
+      sessionId,
+      provider,
+      turnNumber: turn.turnNumber
+    });
+  } else if (content.length < 300 && !toolMatch) {
+    events.push({
+      type: "decision",
+      summary: content.split("\n")[0].slice(0, 200),
+      timestamp,
+      sessionId,
+      provider,
+      turnNumber: turn.turnNumber
+    });
+  }
+  return events;
+}
+function extractFromCodingAssistant(turn, timestamp, sessionId, provider) {
+  const events = [];
+  const content = turn.content;
+  const toolResultMatch = content.match(/\[(\w+)\s*→\s*(\d+(?:\.\d+)?m?s)\]\s*(.*)/);
+  if (toolResultMatch) {
+    const resultPreview = toolResultMatch[3].slice(0, 150);
+    events.push({
+      type: "action",
+      summary: `${toolResultMatch[1]}: ${resultPreview}`,
+      timestamp,
+      sessionId,
+      provider,
+      tool: toolResultMatch[1],
+      turnNumber: turn.turnNumber
+    });
+  }
+  const filePatterns = content.matchAll(/(?:(?:File|Modified|Created|Edited|Deleted)[:\s]+)([^\n,]+\.\w+)/gi);
+  const files = [];
+  for (const match of filePatterns) {
+    files.push(match[1].trim());
+  }
+  if (files.length > 0) {
+    events.push({
+      type: "action",
+      summary: `Modified ${files.length} file(s): ${files.slice(0, 3).join(", ")}${files.length > 3 ? "..." : ""}`,
+      timestamp,
+      sessionId,
+      provider,
+      files,
+      turnNumber: turn.turnNumber
+    });
+  }
+  const errorMatch = content.match(/(?:Error|Failed|error|FAIL)[:\s]+(.+)/);
+  if (errorMatch) {
+    events.push({
+      type: "error",
+      summary: errorMatch[0].slice(0, 200),
+      timestamp,
+      sessionId,
+      provider,
+      turnNumber: turn.turnNumber
+    });
+  }
+  const commitMatch = content.match(/(?:commit|committed|pushed)[:\s]+([a-f0-9]{7,})/i);
+  if (commitMatch) {
+    events.push({
+      type: "commit",
+      summary: `Committed ${commitMatch[1]}`,
+      timestamp,
+      sessionId,
+      provider,
+      turnNumber: turn.turnNumber
+    });
+  }
+  if (events.length === 0 && content.length < 300 && content.length > 10) {
+    events.push({
+      type: "decision",
+      summary: content.split("\n")[0].slice(0, 200),
+      timestamp,
+      sessionId,
+      provider,
+      turnNumber: turn.turnNumber
+    });
+  }
+  return events;
+}
+function extractFromDiscussionAssistant(turn, timestamp, sessionId, provider) {
+  const events = [];
+  const content = turn.content;
+  const lines = content.split("\n").filter((l) => l.trim());
+  if (lines.length > 0) {
+    const firstLine = lines[0].replace(/^#+\s*/, "").trim();
+    if (firstLine.length > 10) {
+      events.push({
+        type: "topic",
+        summary: firstLine.slice(0, 200),
+        timestamp,
+        sessionId,
+        provider,
+        turnNumber: turn.turnNumber
+      });
+    }
+  }
+  const optionLines = lines.filter(
+    (l) => /^(?:\d+\.|[-*]|\*\*Option|Option [A-C])/i.test(l.trim())
+  );
+  if (optionLines.length >= 2) {
+    const summary = optionLines.slice(0, 4).map((l) => l.trim().slice(0, 100)).join("; ");
+    events.push({
+      type: "decision",
+      summary: `Options: ${summary}`,
+      timestamp,
+      sessionId,
+      provider,
+      turnNumber: turn.turnNumber
+    });
+  }
+  const lastLines = lines.slice(-3);
+  for (const line of lastLines) {
+    const trimmed = line.trim();
+    if (/^(?:So|In summary|The (?:key|main|bottom)|To summarize|Overall)/i.test(trimmed)) {
+      events.push({
+        type: "decision",
+        summary: trimmed.slice(0, 200),
+        timestamp,
+        sessionId,
+        provider,
+        turnNumber: turn.turnNumber
+      });
+      break;
+    }
+  }
+  return events;
+}
+function extractTopic(content) {
+  const firstLine = content.split("\n")[0].trim();
+  if (firstLine.length < 5 || firstLine.length > 200) return null;
+  const cleaned = firstLine.replace(/^(?:hey|hi|hello|ok|okay|so|well|please|pls|can you|could you)\s+/i, "").trim();
+  return cleaned.length > 5 ? cleaned.slice(0, 100) : null;
+}
+function deduplicateEvents(events) {
+  const seen = /* @__PURE__ */ new Set();
+  return events.filter((event) => {
+    const key = `${event.type}:${event.summary.toLowerCase().replace(/[^\w\s]/g, "").trim().slice(0, 50)}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+var DOMAIN_LABELS = {
+  planning: "Planning",
+  learning: "Learning",
+  creative: "Creative",
+  operational: "Operations",
+  research: "Research",
+  health: "Health",
+  social: "Social",
+  finance: "Finance",
+  reflection: "Reflection",
+  security: "Security"
+};
+function generateNarrative(sessionType, events, meta, provider) {
+  const time = new Date(meta.created).toLocaleTimeString("en-US", {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  });
+  const parts = [];
+  parts.push(`${time} via ${provider}`);
+  const strategy = getExtractorStrategy(sessionType);
+  if (sessionType !== strategy) {
+    parts.push(`[${DOMAIN_LABELS[sessionType]}]`);
+  }
+  if (strategy === "coding") {
+    const actions = events.filter((e) => e.type === "action");
+    const errors = events.filter((e) => e.type === "error");
+    const commits = events.filter((e) => e.type === "commit");
+    const decisions = events.filter((e) => e.type === "decision");
+    if (decisions.length > 0) parts.push(decisions[0].summary);
+    parts.push(`${actions.length} actions`);
+    if (errors.length > 0) parts.push(`${errors.length} errors`);
+    if (commits.length > 0) parts.push(`${commits.length} commits`);
+  } else if (strategy === "discussion") {
+    const topics = events.filter((e) => e.type === "topic");
+    const decisions = events.filter((e) => e.type === "decision");
+    if (topics.length > 0) parts.push(`Discussed: ${topics.map((t) => t.summary).slice(0, 3).join(", ")}`);
+    if (decisions.length > 0) parts.push(`${decisions.length} decisions`);
+  } else if (strategy === "personal") {
+    const facts = events.filter((e) => e.type === "fact" || e.type === "preference");
+    if (facts.length > 0) parts.push(facts.map((f) => f.summary).join("; "));
+  } else {
+    parts.push(`${events.length} events`);
+  }
+  return parts.join(" \u2014 ");
+}
+
+// ../chitragupta/packages/smriti/src/fact-extractor.ts
+var DEFAULT_CONFIG = {
+  minConfidence: 0.5,
+  useVectors: true,
+  vectorThreshold: 0.65
+};
+var FACT_PATTERNS = [
+  {
+    category: "identity",
+    patterns: [
+      /(?:my name is|i'm called|call me|i am|i'm)\s+([a-z][a-z\s]{1,30})/i,
+      /(?:they call me|people call me|everyone calls me)\s+([a-z][a-z\s]{1,30})/i
+    ],
+    confidence: 0.9
+  },
+  {
+    category: "location",
+    patterns: [
+      /(?:i live in|i'm from|i am from|based in|i'm based in|i reside in|living in|i'm in)\s+([a-z][a-z\s,]{1,50})/i,
+      /(?:my home is in|my city is|i'm located in|located in)\s+([a-z][a-z\s,]{1,50})/i
+    ],
+    confidence: 0.9
+  },
+  {
+    category: "work",
+    patterns: [
+      /(?:i work at|i work for|my company is|i'm at|employed at|employed by)\s+([a-z][a-z\s&.]{1,50})/i,
+      /(?:my job is|my role is|i'm a|i am a|i work as)\s+([a-z][a-z\s]{1,50})/i,
+      /(?:my team|our team|my department)\s+(?:is|works on)\s+([a-z][a-z\s]{1,50})/i
+    ],
+    confidence: 0.85
+  },
+  {
+    category: "preference",
+    patterns: [
+      /(?:always use|i prefer|i use|i like using|we use|we always)\s+([a-z][a-z\s./-]{1,50})/i,
+      /(?:never use|don't use|avoid|i hate|stop using)\s+([a-z][a-z\s./-]{1,50})/i,
+      /(?:my editor is|my ide is|i code in|i develop in|my stack is)\s+([a-z][a-z\s./-]{1,50})/i
+    ],
+    confidence: 0.85
+  },
+  {
+    category: "relationship",
+    patterns: [
+      /(?:my wife|my husband|my partner|my girlfriend|my boyfriend)\s+(?:is|'s)\s+([a-z][a-z\s]{1,30})/i,
+      /(?:my colleague|my friend|my boss|my manager|my coworker)\s+([a-z][a-z\s]{1,30})/i
+    ],
+    confidence: 0.85
+  },
+  {
+    category: "instruction",
+    patterns: [
+      /(?:remember that|don't forget|note that|keep in mind|save (?:that|this))\s+(.{5,200})/i,
+      /(?:from now on|going forward|always remember)\s+(.{5,200})/i
+    ],
+    confidence: 0.95
+  },
+  {
+    category: "personal",
+    patterns: [
+      /(?:my birthday is|i was born on|i was born in)\s+([a-z0-9][a-z0-9\s,]{1,30})/i,
+      /(?:my favorite|my favourite)\s+(\w+)\s+is\s+(.{1,50})/i,
+      /(?:i speak|my language is|my native language)\s+([a-z][a-z\s,]{1,30})/i
+    ],
+    confidence: 0.8
+  }
+];
+var VECTOR_TEMPLATES = [
+  { category: "identity", template: "my name is" },
+  { category: "identity", template: "people call me" },
+  { category: "location", template: "i live in a city" },
+  { category: "location", template: "i am from a country" },
+  { category: "location", template: "i am based in a place" },
+  { category: "work", template: "i work at a company" },
+  { category: "work", template: "my job role is" },
+  { category: "preference", template: "i always prefer to use this tool" },
+  { category: "preference", template: "never use that library" },
+  { category: "relationship", template: "my family member is named" },
+  { category: "instruction", template: "remember this important fact" },
+  { category: "instruction", template: "always do this from now on" },
+  { category: "personal", template: "my birthday is on a date" },
+  { category: "personal", template: "my favorite thing is" }
+];
+var FactExtractor = class {
+  config;
+  embeddingService;
+  templateEmbeddings = /* @__PURE__ */ new Map();
+  initialized = false;
+  /** Recently saved facts (dedup cache). Cleared periodically. */
+  recentFacts = /* @__PURE__ */ new Set();
+  recentFactsCleanupTimer = null;
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.embeddingService = new EmbeddingService();
+  }
+  /**
+   * Initialize vector templates (lazy, on first use).
+   */
+  async ensureInitialized() {
+    if (this.initialized) return;
+    if (!this.config.useVectors) {
+      this.initialized = true;
+      return;
+    }
+    for (const tmpl of VECTOR_TEMPLATES) {
+      const embedding = fallbackEmbedding(tmpl.template);
+      this.templateEmbeddings.set(tmpl.template, embedding);
+    }
+    this.initialized = true;
+    this.recentFactsCleanupTimer = setInterval(() => {
+      this.recentFacts.clear();
+    }, 10 * 60 * 1e3);
+    if (this.recentFactsCleanupTimer.unref) {
+      this.recentFactsCleanupTimer.unref();
+    }
+  }
+  /**
+   * Extract facts from user input text.
+   * Uses pattern matching first, then vector similarity for misses.
+   */
+  async extract(text) {
+    await this.ensureInitialized();
+    const facts = [];
+    if (text.length < 5 || text.length > 5e3) return facts;
+    for (const rule of FACT_PATTERNS) {
+      for (const pattern of rule.patterns) {
+        const match = text.match(pattern);
+        if (match) {
+          const extracted = match[1]?.trim() || match[0].trim();
+          const fact = normalizeFact(rule.category, extracted);
+          if (fact) {
+            facts.push({
+              category: rule.category,
+              fact,
+              source: match[0].trim(),
+              confidence: rule.confidence,
+              method: "pattern"
+            });
+          }
+        }
+      }
+    }
+    if (this.config.useVectors && facts.length === 0) {
+      const inputEmbedding = fallbackEmbedding(text.toLowerCase().slice(0, 200));
+      let bestScore = 0;
+      let bestTemplate = null;
+      for (const tmpl of VECTOR_TEMPLATES) {
+        const tmplEmbedding = this.templateEmbeddings.get(tmpl.template);
+        if (!tmplEmbedding) continue;
+        const score = cosineSimilarity(inputEmbedding, tmplEmbedding);
+        if (score > bestScore) {
+          bestScore = score;
+          bestTemplate = tmpl;
+        }
+      }
+      if (bestTemplate && bestScore >= this.config.vectorThreshold) {
+        const fact = normalizeFact(bestTemplate.category, text.trim());
+        if (fact) {
+          facts.push({
+            category: bestTemplate.category,
+            fact,
+            source: text.trim().slice(0, 200),
+            confidence: Math.min(bestScore, 0.85),
+            // Cap vector confidence slightly lower
+            method: "vector"
+          });
+        }
+      }
+    }
+    return facts.filter((f) => f.confidence >= this.config.minConfidence);
+  }
+  /**
+   * Extract facts and save to memory immediately.
+   * Deduplicates against recently saved facts.
+   *
+   * @param text - User input text.
+   * @param scope - Memory scope to save to (default: global).
+   * @param projectScope - Optional project scope for project-level preferences.
+   * @returns Extracted and saved facts.
+   */
+  async extractAndSave(text, scope, projectScope) {
+    const facts = await this.extract(text);
+    if (facts.length === 0) return [];
+    const { appendMemory, getMemory } = await import("./memory-store-KNJPMBLQ.js");
+    const globalScope = scope ?? { type: "global" };
+    const existingMemory = getMemory(globalScope).toLowerCase();
+    for (const fact of facts) {
+      const dedupeKey = `${fact.category}:${fact.fact.toLowerCase().slice(0, 50)}`;
+      if (this.recentFacts.has(dedupeKey)) continue;
+      if (existingMemory.includes(fact.fact.toLowerCase().slice(0, 30))) continue;
+      const entry = `[${fact.category}] ${fact.fact}`;
+      if (fact.category === "preference" && projectScope) {
+        await appendMemory(projectScope, entry);
+      } else {
+        await appendMemory(globalScope, entry);
+      }
+      this.recentFacts.add(dedupeKey);
+    }
+    return facts;
+  }
+  /**
+   * Cleanup resources.
+   */
+  dispose() {
+    if (this.recentFactsCleanupTimer) {
+      clearInterval(this.recentFactsCleanupTimer);
+      this.recentFactsCleanupTimer = null;
+    }
+  }
+};
+function normalizeFact(category, raw) {
+  const cleaned = raw.replace(/[.!?,;:]+$/, "").trim();
+  if (cleaned.length < 2) return null;
+  switch (category) {
+    case "identity":
+      return `Name: ${capitalize(cleaned)}`;
+    case "location":
+      return `Lives in ${capitalize(cleaned)}`;
+    case "work":
+      return `Works at/as ${cleaned}`;
+    case "preference":
+      return `Preference: ${cleaned}`;
+    case "relationship":
+      return `Relationship: ${cleaned}`;
+    case "instruction":
+      return cleaned;
+    case "personal":
+      return cleaned;
+    default:
+      return cleaned;
+  }
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+var _instance = null;
+function getFactExtractor(config) {
+  if (!_instance) {
+    _instance = new FactExtractor(config);
+  }
+  return _instance;
+}
+
+// ../chitragupta/packages/smriti/src/day-consolidation.ts
+function getDaysRoot() {
+  return path.join(getChitraguptaHome(), "days");
+}
+function getDayFilePath(date) {
+  const match = date.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (!match) throw new SessionError(`Invalid date: ${date}. Expected YYYY-MM-DD.`);
+  return path.join(getDaysRoot(), match[1], match[2], `${match[3]}.md`);
+}
+async function consolidateDay(date, options) {
+  const t0 = performance.now();
+  const dayPath = getDayFilePath(date);
+  if (!options?.force && fs.existsSync(dayPath)) {
+    const content = fs.readFileSync(dayPath, "utf-8");
+    const sessionCount = (content.match(/^### Session:/gm) || []).length;
+    return {
+      date,
+      filePath: dayPath,
+      sessionsProcessed: sessionCount,
+      projectCount: (content.match(/^## Project:/gm) || []).length,
+      totalTurns: 0,
+      extractedFacts: [],
+      durationMs: performance.now() - t0
+    };
+  }
+  let sessions;
+  if (options?.loadSessions) {
+    sessions = await options.loadSessions(date);
+  } else {
+    const { listSessionsByDate, listTurnsWithTimestamps, loadSession } = await import("./session-store-XKPGKXUS.js");
+    const metas = listSessionsByDate(date);
+    sessions = metas.map((meta) => {
+      try {
+        const turns = listTurnsWithTimestamps(meta.id, meta.project);
+        return { meta, turns };
+      } catch {
+        try {
+          const session = loadSession(meta.id, meta.project);
+          const baseTime = new Date(meta.created).getTime();
+          return {
+            meta,
+            turns: session.turns.map((t, i) => ({
+              ...t,
+              createdAt: baseTime + i * 1e3
+            }))
+          };
+        } catch {
+          return { meta, turns: [] };
+        }
+      }
+    });
+  }
+  if (sessions.length === 0) {
+    return {
+      date,
+      filePath: dayPath,
+      sessionsProcessed: 0,
+      projectCount: 0,
+      totalTurns: 0,
+      extractedFacts: [],
+      durationMs: performance.now() - t0
+    };
+  }
+  const projectMap = /* @__PURE__ */ new Map();
+  let totalTurns = 0;
+  for (const { meta, turns } of sessions) {
+    const key = meta.project;
+    if (!projectMap.has(key)) {
+      projectMap.set(key, {
+        project: meta.project,
+        branch: meta.branch,
+        providers: /* @__PURE__ */ new Set(),
+        sessions: [],
+        eventChains: [],
+        turns: [],
+        filesModified: /* @__PURE__ */ new Set()
+      });
+    }
+    const activity = projectMap.get(key);
+    activity.sessions.push(meta);
+    const provider = meta.metadata?.provider ?? meta.agent ?? "unknown";
+    activity.providers.add(provider);
+    if (meta.branch) activity.branch = meta.branch;
+    const eventChain = extractEventChain(meta, turns);
+    activity.eventChains.push(eventChain);
+    for (const turn of turns) {
+      totalTurns++;
+      activity.turns.push({ ...turn, sessionId: meta.id, createdAt: turn.createdAt });
+    }
+    for (const event of eventChain.events) {
+      if (event.files) {
+        for (const f of event.files) {
+          activity.filesModified.add(f);
+        }
+      }
+    }
+    activity.turns.sort((a, b) => a.createdAt - b.createdAt);
+  }
+  const extractedFacts = await extractFactsWithEngine(sessions);
+  const markdown = generateDayMarkdown(date, projectMap, sessions.length, totalTurns, extractedFacts);
+  const dir = path.dirname(dayPath);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(dayPath, markdown, "utf-8");
+  try {
+    const { indexConsolidationSummary } = await import("./consolidation-indexer-TOTTDZXW.js");
+    await indexConsolidationSummary("daily", date, markdown);
+  } catch {
+  }
+  return {
+    date,
+    filePath: dayPath,
+    sessionsProcessed: sessions.length,
+    projectCount: projectMap.size,
+    totalTurns,
+    extractedFacts,
+    durationMs: performance.now() - t0
+  };
+}
+async function extractFactsWithEngine(sessions) {
+  const facts = [];
+  const seen = /* @__PURE__ */ new Set();
+  try {
+    const extractor = new FactExtractor({ useVectors: true });
+    for (const { turns } of sessions) {
+      for (const turn of turns) {
+        if (turn.role !== "user") continue;
+        if (turn.content.length < 5 || turn.content.length > 5e3) continue;
+        const extracted = await extractor.extract(turn.content);
+        for (const fact of extracted) {
+          const key = fact.fact.toLowerCase().slice(0, 50);
+          if (!seen.has(key)) {
+            seen.add(key);
+            facts.push(`[${fact.category}] ${fact.fact}`);
+          }
+        }
+      }
+    }
+    extractor.dispose();
+  } catch {
+    return extractFactsFallback(sessions);
+  }
+  return facts;
+}
+function extractFactsFallback(sessions) {
+  const facts = [];
+  const factPatterns = [
+    /(?:i live in|i'm from|i am from|my home is in)\s+([^.!?\n]+)/i,
+    /(?:my name is|i'm called|i am called)\s+([^.!?\n]+)/i,
+    /(?:i work at|i work for|my company is)\s+([^.!?\n]+)/i,
+    /(?:i use|i prefer|my editor is|my ide is)\s+([^.!?\n]+)/i,
+    /(?:always use|never use|remember to|don't forget)\s+([^.!?\n]+)/i
+  ];
+  for (const { turns } of sessions) {
+    for (const turn of turns) {
+      if (turn.role !== "user") continue;
+      for (const pattern of factPatterns) {
+        const match = turn.content.match(pattern);
+        if (match) {
+          facts.push(match[0].trim());
+        }
+      }
+    }
+  }
+  return [...new Set(facts)];
+}
+function generateDayMarkdown(date, projectMap, sessionCount, totalTurns, facts) {
+  const lines = [];
+  const dayName = (/* @__PURE__ */ new Date(`${date}T12:00:00Z`)).toLocaleDateString("en-US", { weekday: "long" });
+  lines.push(`# ${date} \u2014 ${dayName}`);
+  lines.push("");
+  lines.push(`> ${sessionCount} sessions | ${projectMap.size} projects | ${totalTurns} turns`);
+  lines.push("");
+  if (facts.length > 0) {
+    lines.push("## Facts Learned");
+    lines.push("");
+    for (const fact of facts) {
+      lines.push(`- ${fact}`);
+    }
+    lines.push("");
+  }
+  for (const [, activity] of projectMap) {
+    lines.push(`## Project: ${activity.project}`);
+    lines.push("");
+    const meta = [];
+    if (activity.branch) meta.push(`**Branch**: ${activity.branch}`);
+    meta.push(`**Providers**: ${[...activity.providers].join(", ")}`);
+    meta.push(`**Sessions**: ${activity.sessions.length}`);
+    if (activity.filesModified.size > 0) {
+      meta.push(`**Files Modified**: ${activity.filesModified.size}`);
+    }
+    lines.push(meta.join(" | "));
+    lines.push("");
+    for (let i = 0; i < activity.sessions.length; i++) {
+      const session = activity.sessions[i];
+      const chain = activity.eventChains[i];
+      const time = new Date(session.created).toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", hour12: false });
+      const provider = session.metadata?.provider ?? session.agent ?? "unknown";
+      const turnCount = activity.turns.filter((t) => t.sessionId === session.id).length;
+      lines.push(`### Session: ${session.id}`);
+      lines.push(`*${time} | ${provider} | ${turnCount} turns | ${chain?.sessionType ?? "unknown"} session*`);
+      lines.push("");
+      if (chain) {
+        if (chain.narrative) {
+          lines.push(`> ${chain.narrative}`);
+          lines.push("");
+        }
+        if (chain.topics.length > 0) {
+          lines.push(`**Topics**: ${chain.topics.slice(0, 5).join(", ")}`);
+          lines.push("");
+        }
+        const keyEvents = chain.events.filter(
+          (e) => e.type === "decision" || e.type === "error" || e.type === "commit" || e.type === "fact" || e.type === "preference"
+        );
+        if (keyEvents.length > 0) {
+          for (const event of keyEvents.slice(0, 10)) {
+            const icon = eventIcon(event.type);
+            lines.push(`- ${icon} ${event.summary}`);
+          }
+          lines.push("");
+        }
+      }
+    }
+    const toolCounts = /* @__PURE__ */ new Map();
+    for (const chain of activity.eventChains) {
+      for (const event of chain.events) {
+        if (event.tool) {
+          toolCounts.set(event.tool, (toolCounts.get(event.tool) ?? 0) + 1);
+        }
+      }
+    }
+    if (toolCounts.size > 0) {
+      lines.push("### Tools Used");
+      lines.push("");
+      for (const [tool, count] of toolCounts) {
+        lines.push(`- **${tool}**: ${count} calls`);
+      }
+      lines.push("");
+    }
+    if (activity.filesModified.size > 0) {
+      lines.push("### Files Modified");
+      lines.push("");
+      for (const f of activity.filesModified) {
+        lines.push(`- ${f}`);
+      }
+      lines.push("");
+    }
+  }
+  lines.push("---");
+  lines.push(`*Consolidated by Chitragupta at ${(/* @__PURE__ */ new Date()).toISOString()}*`);
+  lines.push("");
+  return lines.join("\n");
+}
+function eventIcon(type) {
+  switch (type) {
+    case "decision":
+      return "**Decision**:";
+    case "error":
+      return "**Error**:";
+    case "commit":
+      return "**Commit**:";
+    case "fact":
+      return "**Fact**:";
+    case "preference":
+      return "**Pref**:";
+    case "question":
+      return "**Q**:";
+    case "action":
+      return "**Action**:";
+    case "topic":
+      return "**Topic**:";
+    case "problem":
+      return "**Problem**:";
+    default:
+      return "-";
+  }
+}
+function readDayFile(date) {
+  const dayPath = getDayFilePath(date);
+  if (!fs.existsSync(dayPath)) return null;
+  return fs.readFileSync(dayPath, "utf-8");
+}
+function listDayFiles() {
+  const daysRoot = getDaysRoot();
+  if (!fs.existsSync(daysRoot)) return [];
+  const dates = [];
+  try {
+    const years = fs.readdirSync(daysRoot, { withFileTypes: true });
+    for (const year of years) {
+      if (!year.isDirectory()) continue;
+      const yearPath = path.join(daysRoot, year.name);
+      const months = fs.readdirSync(yearPath, { withFileTypes: true });
+      for (const month of months) {
+        if (!month.isDirectory()) continue;
+        const monthPath = path.join(yearPath, month.name);
+        const days = fs.readdirSync(monthPath);
+        for (const day of days) {
+          if (!day.endsWith(".md")) continue;
+          const dd = day.replace(".md", "");
+          dates.push(`${year.name}-${month.name}-${dd}`);
+        }
+      }
+    }
+  } catch {
+  }
+  return dates.sort().reverse();
+}
+function searchDayFiles(query, options) {
+  const limit = options?.limit ?? 10;
+  const dates = listDayFiles();
+  const results = [];
+  const queryLower = query.toLowerCase();
+  for (const date of dates) {
+    if (results.length >= limit) break;
+    const content = readDayFile(date);
+    if (!content) continue;
+    const lines = content.split("\n");
+    const matches = [];
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].toLowerCase().includes(queryLower)) {
+        matches.push({ line: i + 1, text: lines[i].trim() });
+      }
+    }
+    if (matches.length > 0) {
+      results.push({ date, matches: matches.slice(0, 5) });
+    }
+  }
+  return results;
+}
+function isDayConsolidated(date) {
+  return fs.existsSync(getDayFilePath(date));
+}
+async function getUnconsolidatedDates(limit) {
+  const { listSessionDates } = await import("./session-store-XKPGKXUS.js");
+  const sessionDates = listSessionDates();
+  const unconsolidated = [];
+  for (const date of sessionDates) {
+    if (unconsolidated.length >= (limit ?? 30)) break;
+    if (!isDayConsolidated(date)) {
+      unconsolidated.push(date);
+    }
+  }
+  return unconsolidated;
+}
+
+export {
+  detectSessionType,
+  getExtractorStrategy,
+  extractEventChain,
+  FactExtractor,
+  getFactExtractor,
+  getDaysRoot,
+  getDayFilePath,
+  consolidateDay,
+  readDayFile,
+  listDayFiles,
+  searchDayFiles,
+  isDayConsolidated,
+  getUnconsolidatedDates
+};
+//# sourceMappingURL=chunk-H76V36OF.js.map