Add smart follow-up detection for history context

Instead of always sending the previous exchange to the LLM, use a
time + signal word heuristic to decide if the query is a follow-up:
- Under 2 min: always include history
- 2-10 min: only if query is short or contains follow-up words
- Over 10 min: never include history

Prevents unrelated questions from being misinterpreted as follow-ups
to stale context. Backward compatible with old history files (missing
timestamp treated as expired).

Author: matlimatli

include/HistoryManager.h

@@ -1,12 +1,14 @@
 #pragma once
 
+#include <ctime>
 #include <optional>
 #include <string>
 #include <utility>
 
 struct Exchange {
     std::string userQuery;
     std::string assistantReply;
+    std::time_t timestamp{0};
 };
 
 class HistoryManager {
@@ -19,6 +21,10 @@ class HistoryManager {
     /// Save the current exchange, creating the directory and enforcing 0600.
     void save(const std::string& userQuery, const std::string& assistantReply) const;
 
+    /// Decide whether the current query is a follow-up to a previous exchange.
+    [[nodiscard]] static bool isFollowUp(const Exchange& previous, const std::string& currentQuery,
+                                         std::time_t now = std::time(nullptr));
+
   private:
     [[nodiscard]] std::string resolvePath() const;
 

src/HistoryManager.cpp

@@ -1,11 +1,16 @@
 #include "HistoryManager.h"
 
+#include <algorithm>
+#include <ranges>
+#include <cctype>
 #include <cstdlib>
 #include <filesystem>
 #include <fstream>
 #include <nlohmann/json.hpp>
+#include <sstream>
 #include <stdexcept>
 #include <sys/stat.h>
+#include <unordered_set>
 
 HistoryManager::HistoryManager(std::string path) : path_(std::move(path)) {}
 
@@ -30,8 +35,10 @@ std::optional<Exchange> HistoryManager::loadPrevious() const {
 
     try {
         auto json = nlohmann::json::parse(file);
+        std::time_t ts = json.value("timestamp", static_cast<std::time_t>(0));
         return Exchange{.userQuery = json.at("user").get<std::string>(),
-                        .assistantReply = json.at("assistant").get<std::string>()};
+                        .assistantReply = json.at("assistant").get<std::string>(),
+                        .timestamp = ts};
     } catch (const nlohmann::json::exception&) {
         return std::nullopt;
     }
@@ -46,6 +53,7 @@ void HistoryManager::save(const std::string& userQuery, const std::string& assis
     nlohmann::json json;
     json["user"] = userQuery;
     json["assistant"] = assistantReply;
+    json["timestamp"] = std::time(nullptr);
 
     std::ofstream file(resolved, std::ios::trunc);
     if (!file.is_open()) {
@@ -59,3 +67,50 @@ void HistoryManager::save(const std::string& userQuery, const std::string& assis
         throw std::runtime_error("Cannot set permissions on history file: " + resolved);
     }
 }
+
+namespace {
+
+std::vector<std::string> splitAndLower(const std::string& text) {
+    std::vector<std::string> words;
+    std::istringstream stream(text);
+    std::string word;
+    while (stream >> word) {
+        std::ranges::transform(word, word.begin(),
+                               [](unsigned char c) { return std::tolower(c); });
+        words.push_back(std::move(word));
+    }
+    return words;
+}
+
+} // namespace
+
+bool HistoryManager::isFollowUp(const Exchange& previous, const std::string& currentQuery,
+                                std::time_t now) {
+    const double elapsed = std::difftime(now, previous.timestamp);
+    constexpr double kRapidWindow = 120.0; // 2 minutes
+    constexpr double kMaxWindow = 600.0;   // 10 minutes
+
+    if (elapsed > kMaxWindow) {
+        return false;
+    }
+    if (elapsed <= kRapidWindow) {
+        return true;
+    }
+
+    // Between 2–10 minutes: check for follow-up signals
+    auto words = splitAndLower(currentQuery);
+    if (!words.empty()) {
+        words.erase(words.begin()); // drop command name
+    }
+
+    if (words.size() <= 3) {
+        return true;
+    }
+
+    static const std::unordered_set<std::string> signals = {
+        "it",      "this",          "that",     "them",    "those",   "these",   "also",  "again",
+        "instead", "but",           "more",     "another", "same",    "similar", "too",   "else",
+        "however", "alternatively", "previous", "last",    "earlier", "before",  "above",
+    };
+    return std::ranges::any_of(words, [&](const std::string& w) { return signals.contains(w); });
+}

src/main.cpp

@@ -54,8 +54,8 @@ int main(int argc, char* argv[]) {
     const HistoryManager history;
     std::vector<Message> messages;
 
-    auto previous = history.loadPrevious();
-    if (previous) {
+    const auto previous = history.loadPrevious();
+    if (previous && HistoryManager::isFollowUp(*previous, query.str())) {
         messages.push_back({.role = "user", .content = previous->userQuery});
         messages.push_back({.role = "assistant", .content = previous->assistantReply});
     }

tests/HistoryManagerTest.cpp

@@ -99,6 +99,57 @@ TEST_F(HistoryManagerTest, SaveCreatesParentDirectories) {
     EXPECT_EQ(result->userQuery, "query");
 }
 
+// --- Follow-up detection tests ---
+
+TEST(FollowUpTest, ExpiredHistoryReturnsFalse) {
+    Exchange ex{.userQuery = "how to list files",
+                .assistantReply = "Use ls",
+                .timestamp = 1000};
+    // 20 minutes later
+    EXPECT_FALSE(HistoryManager::isFollowUp(ex, "how does photosynthesis work", 2200));
+}
+
+TEST(FollowUpTest, RecentHistoryAlwaysReturnsTrue) {
+    Exchange ex{.userQuery = "how to list files",
+                .assistantReply = "Use ls",
+                .timestamp = 1000};
+    // 30 seconds later, unrelated query
+    EXPECT_TRUE(HistoryManager::isFollowUp(ex, "how does photosynthesis work", 1030));
+}
+
+TEST(FollowUpTest, MediumAgeWithSignalWordReturnsTrue) {
+    Exchange ex{.userQuery = "how to list files",
+                .assistantReply = "Use ls",
+                .timestamp = 1000};
+    // 5 minutes later, "but" is a signal word
+    EXPECT_TRUE(HistoryManager::isFollowUp(ex, "how but only in the home directory", 1300));
+}
+
+TEST(FollowUpTest, MediumAgeWithShortQueryReturnsTrue) {
+    Exchange ex{.userQuery = "how to list files",
+                .assistantReply = "Use ls",
+                .timestamp = 1000};
+    // 5 minutes later, short query (2 content words after command name)
+    EXPECT_TRUE(HistoryManager::isFollowUp(ex, "how in rust", 1300));
+}
+
+TEST(FollowUpTest, MediumAgeWithLongUnrelatedQueryReturnsFalse) {
+    Exchange ex{.userQuery = "how to list files",
+                .assistantReply = "Use ls",
+                .timestamp = 1000};
+    // 5 minutes later, long query with no signal words
+    EXPECT_FALSE(HistoryManager::isFollowUp(ex, "how does photosynthesis work in plants", 1300));
+}
+
+TEST(FollowUpTest, ZeroTimestampReturnsFalse) {
+    Exchange ex{.userQuery = "how to list files",
+                .assistantReply = "Use ls",
+                .timestamp = 0};
+    EXPECT_FALSE(HistoryManager::isFollowUp(ex, "how in rust", std::time(nullptr)));
+}
+
+// --- Existing tests ---
+
 TEST_F(HistoryManagerTest, SaveProducesValidJson) {
     auto path = historyPath();
     HistoryManager mgr(path);