Dijaview: What Did I Do Last Tuesday? A Privacy-First Local Activity Engine Powered by Gemma 2

Snow — Mon, 05 Oct 2026 09:25:11 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I built

Dijaview is an open-source, local-first search engine that lets you ask plain-English questions about everything you have done on your computer, without sending any personal data to the cloud.

Instead of manually grepping through project directories, scrolling endlessly through shell history, or searching through thousands of browser tabs:

"Where did I save that API key documentation I looked at last Tuesday?"

"What was that complex curl command with custom headers I ran yesterday?"

"Where did I write down the database connection settings?"

Dijaview indexes your local shell commands, browser history, and notes. It parses time expressions deterministically, filters candidate records using full-text search with BM25 ranking, and uses Google's Gemma 2 open-weight model to synthesize a direct answer with clickable links and source citations.

Built for a friend

I built Dijaview for my friend Mohammed Adamu Aliyu (@Adams-404), a software engineer and builder who spends hours in terminal sessions, testing endpoints, and juggling dozens of open documentation tabs across multiple projects.

Mohammed frequently ran into the friction of retracing past work:

"I was constantly digging through thousands of lines of bash history or searching through browser tabs just to find a curl command or endpoint doc from two days ago. Having a tool on my local machine that lets me ask in plain English where I did something or find a command without uploading my history to anyone else is a game changer."

Dijaview solves this directly on his local machine with zero telemetry.

Demo

GitHub repository: https://github.com/Icedmist/dijaview
CLI query:

  dijaview query "When did I run git status?"

Real output from local Gemma 2 2B:

  Answer:
  The user ran `git status` on three separate occasions: index 1, 2, and 3. They are located in the .bash_history file.

  Sources Cited:
    [1] (Terminal) Terminal Command: git status
        Location: /home/snow/.bash_history
        Time:     2026-10-02T13:21:37.095089
    [2] (Terminal) Terminal Command: git status
        Location: /home/snow/.bash_history
        Time:     2026-10-02T13:21:37.095089
    [3] (Terminal) Terminal Command: git status
        Location: /home/snow/.bash_history
        Time:     2026-10-02T13:21:37.095089

Code

The entire codebase is open-source under the MIT license:

Icedmist / dijaview

Privacy-first, local-first personal computer activity & context search engine powered by Gemma 2.

Dijaview

A privacy-first, local search engine for your computer activity powered by Gemma 2.
Ask questions about what you did on your computer without sending any data to the cloud.

The problem

Developers and computer users lose time every day trying to remember where they saw or did something:

"Where did I save that API key documentation I read last Tuesday?"
"What was that complex curl command with custom headers I ran yesterday?"
"Which browser tab had the article about Fastify CORS configuration?"
"Where in my notes did I write down the database connection schema?"

Normally, you have to remember which tool you used, grep through folders, scroll through thousands of shell history lines, or dig through browser history tables.

Tools like Microsoft Recall tried to solve this, but they generated widespread security criticism. They stored plain text files and sent data across the network. Cloud based tools charge monthly…

View on GitHub

How I built it

Dijaview is engineered from the ground up around open-source AI and local execution:

+---------------------------------------+
|              Data Sources             |
|   * Shell History (bash/zsh/fish)     |
|   * Browser History (SQLite)          |
|   * Local Notes & Markdown Files      |
+-------------------┬-------------------+
                    |
                    v
+---------------------------------------+
|     Secret Scrubbing & Ingestion      |
|   * Heuristic credential masking      |
|   * Size caps & path permissions      |
+-------------------┬-------------------+
                    |
                    v
+---------------------------------------+
|     Embedded SQLite & BM25 Store      |
|   * FTS5 Full-Text Search             |
|   * User-only file security (0600)    |
|   * Stopword filtering & BM25 rank    |
+-------------------┬-------------------+
                    |
                    v
+---------------------------------------+
|          Gemma 2 RAG Engine           |
|   * Deterministic Temporal Parser     |
|   * Prompt Injection Defense Pass     |
|   * Local Gemma 2 Synthesis           |
|   * Strict Source Citation Protocol   |
+---------------------------------------+

Local Model Synthesis (Gemma 2): We use Google's Gemma 2 (2B) running locally via Ollama. Gemma 2 synthesizes concise answers and extracts source citations from retrieved context. The 2B model is lightweight (1.7 GB) and runs comfortably on CPU with zero external GPUs required. For systems with more memory, the Gemma 2 9B model can be used by changing model.name in configuration.
Deterministic Time Parsing: Rather than relying on model guessing for dates, temporal.py parses time expressions like "last Tuesday" or "yesterday" using deterministic regular expressions and Python datetime math to calculate exact start and end timestamps.
Embedded SQLite with BM25 Ranking: Indexed entries are stored in a local SQLite database (~/.local/share/dijaview/dijaview.db). Text search strips generic stopwords and uses SQLite FTS5 bm25() ranking so records matching multiple keywords appear first.
Proactive Secret Redaction: Every entry passes through an automated regex filter that sanitizes API keys (ghp_, sk_live_, pk_live_), JWTs, CLI passwords (mysql -p, curl -u, sshpass -p), and shell exports before indexing.
Prompt Injection Defenses: Retrieved snippets are wrapped in strict passive data tags, code block delimiters are sanitized, and the system prompt explicitly commands Gemma 2 to treat retrieved content as passive historical data, ignoring any embedded instructions like "ignore previous rules".

Why open matters

Your computer activity log is the single most intimate record of your digital life: every command you typed, every documentation article you read, every draft note you scribbled, and every project you touched. Entrusting this data to a closed system is unacceptable.

Here is why open architecture is the only viable foundation for personal activity search:

Local Gemma 2 intelligence:

Google's Gemma 2 open weights make it possible to run sophisticated language models entirely on personal hardware. The model runs locally via Ollama or llama.cpp, meaning your questions and retrieved records never leave your machine. You get the benefits of modern AI without sending your digital life to a corporate server.
Absolute zero telemetry:

Closed commercial software routinely phones home with diagnostic logs, usage metrics, and behavioral telemetry. Dijaview has zero network telemetry. There are no tracking beacons, no analytics pings, and no cloud dependencies. The only network socket ever created is an optional local web server bound to 127.0.0.1 and protected by a random per-launch authentication token.
Auditable redaction over black-box promises:

In privacy software, "trust us" is not a security guarantee. Proprietary tools hide their filtering behind closed APIs. Dijaview's secret scrubbing rules are completely open, inspectable regular expressions in redactor.py. Anyone can audit how Stripe keys, JWTs, AWS credentials, and CLI passwords are sanitized. If a specific format is missing, you can add custom rules with dijaview permissions add-filter rather than hoping a third party protects you.
Swappable models and no vendor lock-in:

Dijaview is not married to a single model provider or cloud platform. Because the engine interfaces through standard local endpoints, you can swap models freely. You can start with Gemma 2 2B, switch to Gemma 2 9B for deeper synthesis, or plug in any other open-weight model supported by Ollama without rewriting core business logic.
Naming the tradeoff: 2B model limitations:

Being honest about trade-offs is essential in open-source engineering. The default Gemma 2 2B model is remarkably fast and runs comfortably on modest laptop CPUs with less than 2 GB of memory. But a 2-billion parameter model has real weaknesses:
- Its answers can be terse or overly literal.
- When multiple complex records are retrieved, 2B models can struggle with subtle reasoning, occasionally producing flat summaries or missing nuanced connections.
- It cannot handle massive prompt contexts without losing coherence.

This tradeoff is precisely why Dijaview does not rely on the LLM to search. Instead, deterministic Python regex extracts dates, and SQLite FTS5 with BM25 ranking finds the most relevant records first. Gemma 2 is only asked to synthesize pre-filtered, verified records and cite their exact line locations. And when a user has more RAM and needs richer reasoning, the open architecture allows an instant upgrade to the 9B model.

Limitations

Heuristic secret redaction: Secret redaction uses pattern matching and regular expressions. While it catches standard formats (JWTs, Bearer tokens, GitHub, Stripe, Paystack, AWS, CLI passwords), it is best-effort and cannot guarantee 100% coverage of custom proprietary tokens. Users can register custom patterns with dijaview permissions add-filter.
Unencrypted local database: The local SQLite database file is stored unencrypted on disk with user-only permissions (chmod 600). Dijaview relies on OS-level full-disk encryption (such as LUKS on Linux, FileVault on macOS, or BitLocker on Windows) to protect data at rest.
Compact model reasoning: Gemma 2 2B is a 2-billion parameter model optimized for fast CPU inference. While it reliably cites evidence and summarizes records, users with 16 GB or more RAM can upgrade to Gemma 2 9B for deeper synthesis.
Prompt injection risks: While Dijaview implements defensive data tagging and snippet sanitization, indexing untrusted external web pages or markdown files requires ongoing defensive vigilance in all local RAG architectures.

Prize categories

Featured Category: Best Use of Gemma
- Dijaview utilizes Google's Gemma 2 open-weight model as its central brain for synthesizing answers and extracting source citations from retrieved computer activity.
Overall Challenge Winner
- Delivering a complete, privacy-first local search engine built for a developer friend, embodying the true spirit of open-source AI and data sovereignty.

Built with care during Hacktoberfest 2026 Weekend Challenge 1.

hello dev.to, be good to me.

Snow — Sun, 03 May 2026 15:33:29 +0000

Hey Dev.to 👋
I'm Nasir Ibrahim Imam, a full stack developer based in Gombe, Nigeria. I go by @icedmist on GitHub.
I've been building for a while now and my GitHub is pretty green — but I figured it's time to actually show up in communities and connect with people who are building things that matter.
What I work with:
React, Next.js, Flutter, Firebase, Node.js — mostly full stack web and mobile, with some AI integration sprinkled in.
Why I'm here:
I want to collaborate with devs across the world, contribute to open source, and eventually co-found something with people who actually ship. I'm open to remote work, hackathons, and long-term build partnerships.
If you're working on something in EdTech, AgriTech, or DevTools — or just want to connect with a dev from Nigeria who's building in public — say hi.
GitHub: github.com/icedmist
Let's build something. 🚀

DEV Community: Snow