Which Copy Do I Keep? Sloth-Powered Folder Tidying with a Local Gemma

atif-1402 — Tue, 20 Oct 2026 17:17:17 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

Somewhere in your files sit contract.pdf, contract_final.pdf, contract_final_v2(1).pdf, and contract_FINAL (copy).pdf — the same document, four times over. You know one of them is the real one. You don't know which one. So you open all four, squint at the footer, find the signed copy, close three tabs — or worse, you pick wrong and sign the wrong version.

Keeper answers that question for you. Point it at a folder: it clusters version-clone files by actual content (not filename), asks a local open-weight model which copy is the keeper and why, and quarantines the rest. Dry-run by default. It never deletes a thing.

That's the whole sloth move — a task you've been putting off for years, done by one command while you get a coffee.

The model suggests; you keep the final say. All of this is in v0.1.6, released Friday:

--interactive — Keeper walks each cluster in turn and asks you. Press Enter to accept the verdict, type a number to keep a different copy, s to leave that cluster alone, q to stop. It stays a dry run the whole way — nothing moves without --apply.
--only 1,3,5 / --skip 2 — act on a subset of clusters (ranges work too: 2-4). Numbering is stable across runs, so --only 7 still reads as cluster 7 in the table, the JSON and the Markdown report.
Targeting — --ext pdf,jpg, --min-size 10k, --include 'rental*', --exclude 'reports/*'. The filters run during the walk, so a file you excluded is never hashed and never read.
--max-hash-mb 512 — the byte-identical pass used to stop at 64 MB, which quietly hid the big files: a re-downloaded installer, two copies of the same video. The default is now 512 MB; 0 means no limit.
--quiet — nothing but errors, for cron and CI.
--fail-on-clutter — exits 3 when there's work to do and 0 when the folder is tidy, so a script can tell "findings" apart from "it broke".

If you disagree with it

Real output from a small test folder — the model and the rules both preferred report_v2.txt, I didn't:

$ keeper client-docs --interactive
Cluster 1 of 4 — 3 copies
  1. [loser] report.txt  (73 B)
  2. [loser] report_final.txt  (92 B)
  3. [keep] report_v2.txt  (109 B)
  why: newest signed copy  [rule, confidence 0.60]
  [Enter] accept · [number] keep that copy · [s] skip · [q] stop > 1
  keeper is now report.txt

Cluster 2 of 4 — 2 copies
  1. [loser] data.bin  (4.0 KB)
  2. [keep] data.bin.bak  (4.0 KB)
  why: all copies are byte-identical; kept the newest timestamp  [identical, confidence 1.00]
  [Enter] accept · [number] keep that copy · [s] skip · [q] stop > q

  Review stopped — 2 cluster(s) after this one will not be touched.

DRY RUN — nothing was moved (2 loser(s) would be quarantined · 201 B of duplicate clutter).
Run again with --apply to quarantine them, or --restore to undo.

That row comes back in the table as ◆ you — you chose copy 1. You were looking at the actual files, size and name in front of you, instead of a confidence score — and the override still went through the same dry run, manifest and --restore as every other verdict. Quit early and the clusters you never reviewed are left alone, not swept up.

Demo

In my case it takes time — I'm on a low-end device, and local LLMs are heavy. Sorry for the bad quality!

A full run on my test folder: scan → spinner with a self-measured ETA → verdict table → --apply quarantines the 8 losers. Nothing was deleted.

Code

atif-1402 / keeper

Which file do I keep? Finds version-clone files in a folder and asks a local open-weight model (Ollama + Gemma) which copy wins — and why. Dry-run by default, never deletes, fully reversible.

Finds version-clone files in any folder, asks a local open-weight model which copy to keep, and quarantines the rest — dry-run by default, 100% offline

Demo · Install · How it works · Safety model · CLI · Why open weights

Demo

In my case it takes time — I'm on a low-end device, and local LLMs are heavy. Sorry for the bad quality!

Why this exists

Duplicate finders tell you files are identical. Diff tools make you pick the two files to compare by hand. Neither one answers the question you actually have: "I have five versions of the same document — which one do I keep?"

Keeper walks the folder itself, clusters the versions, and gives you a colored verdict table with a one-line reason per cluster. While it works you get a live spinner — one line that updates itself (hashing files → extracting text →…

View on GitHub

curl -fsSL https://raw.githubusercontent.com/atif-1402/keeper/main/install.sh | bash

ollama pull gemma3:1b  # ~800 MB, runs on 4 GB RAM
keeper ~/Documents  # dry run — moves nothing

Windows runs it today via pipx install git+https://github.com/atif-1402/keeper; release v0.1.6 ships standalone binaries for Linux (x64/arm64), macOS and Windows. No Ollama? Keeper falls back to its rule engine and tells you so.

Repo: github.com/atif-1402/keeper
Release: v0.1.6
This challenge: Slow and Steady on the HF26 hub

How I Built It

gemma3:1b through local Ollama — an ~800 MB open-weight model that runs in 4 GB RAM. No API keys, no cloud, no ML framework in the codebase: grouping is TF-IDF cosine similarity over filename tokens and extracted text, image matching is a 64-bit perceptual hash, and everything is pure Python.

folder ─▶ scan (hash + metadata) ─▶ extract (txt/md/csv/pdf/docx)
  ─▶ group (filename tokens + TF-IDF cosine) ─▶ decide ─▶ report
  │
  `--apply` ─▶ _keeper_quarantine/ + manifest

Scan — walks the folder (skipping .git, node_modules, and its own quarantine), records size, mtime, sha256.
Extract — pulls text from documents; images, video and archives are recognized as media up front so their bytes are never decoded into garbage "text". A scanned PDF with no text layer is honestly flagged instead of treated as empty.
Group — byte-identical files cluster by hash; near-duplicates cluster by filename-token overlap (browser notes (1).md suffixes stripped) and content similarity — and since v0.1.5, visually near-identical images cluster by perceptual hash: a screenshot saved as photo.png and re-exported as photo.jpg is the same picture with different bytes, and a 64-bit difference hash sees it. Names carrying different identity numbers (S01E01 vs S01E02, Lesson13 vs Lesson14) are never merged — episodes and numbered lessons stay apart.
Decide — only clusters with readable text ever reach the model. Byte-identical clusters and unreadable ones (zips, images, videos) are settled instantly from metadata, so a low-end machine runs Gemma only when it actually matters. Each call is temperature 0, capped output, with a server-side JSON schema — the model structurally cannot answer in any other shape than {keep, reason, confidence}. A verdict it isn't confident about gets one richer second look (more copies, longer excerpts); still unsure, Keeper says "the model was unsure after two looks" and the rules decide. An agent that knows when it doesn't know.
Quarantine — --apply moves losers into _keeper_quarantine/<group>/ with a manifest.json and a portable restore.sh.

The safety net

If the model's pick contradicts hard evidence — the signed copy, the newest timestamp — a transparent rule engine overrules it. Look at row 3 in the demo: the model disagreed on the contract, and the newest copy won on metadata, with the override stated plainly in the table (◐ rule — model disagreed). I'd rather ship a tool that's right than one that's confidently wrong. Rule modes are yours too: --no-model (rules only, instant) and --model-only (hard-error if Ollama is down).

And the three guarantees everything else rests on:

Dry-run by default — nothing moves without --apply, including after an --interactive review.
Never deletes — losers are moved into _keeper_quarantine/<group>/; the manifest records origin, size and SHA-256 for every one.
Fully reversible — keeper <folder> --restore returns the folder to its exact prior state, verified byte-for-byte by tests (95 of them).

Why Does Open Innovation Matter?

The files Keeper reads are contracts, passports, medical letters, tax returns. Shipping filenames and text excerpts to a closed cloud model is exactly the wrong default for this job. gemma3:1b (~800 MB, runs in 4 GB RAM) reads your lease agreement on your laptop and forgets it when the process exits — no API keys, no telemetry, no network calls beyond localhost:11434.

That's what an open-weight model buys you: a private assistant with no exfiltration surface and no vendor who can change the terms next quarter. And the whole reasoning pipeline — grouping, prompting, fallback rules — is in one repo, auditable in an afternoon.

The Lazy Payoff

Honest numbers from my own machine — a 4-core low-end box:

A real 211-file folder of mine → 35 duplicate clusters, 92 losing copies identified, in about a minute. Only 9 clusters called the model; everything else was decided instantly from metadata.
Doing that by hand means opening 92 files, comparing them, deciding. That's an afternoon I'm never getting back. Keeper: one command.
Every run ends with the weight: 8 loser(s) would be quarantined · 37.3 KB of duplicate clutter — one number that says how much you've been carrying.
On a fast machine the model calls take seconds; on mine the spinner honestly shows minutes ([3/9] · about 40s left) — measured throughput, no fake progress bar.

Prize Categories

Best Use of Gemma — featured category.

gemma3:1b is Keeper's default model, run through local Ollama. Every cluster the hash and the metadata can't settle goes to Gemma, which returns {keep, reason, confidence} through a server-side JSON schema and writes the one-line explanation you read in the verdict table — the "newest signed copy" style reasons are its words, not a template. --model gemma3:4b swaps in the larger Gemma for a second opinion. No cloud model is involved at any point.

Thanks for reading — point it at the folder you keep meaning to sort, and enjoy International Sloth Day.

Disclosure: this article was created with the help of AI.

I created parse to solve the problem of messy cli outputs

atif-1402 — Thu, 08 Oct 2026 06:06:46 +0000

I create parse to solve the problem of messy and non-understandable outputs. Parse make the outputs of the currently supported commands into easily understandable and format.

It is single go binary and standard library only.

We can use it like parse COMMAND or COMMAND | parse . You can install it by

go install github.com/atif-1402/parse@latest

Would love to hear peoples feedback on this project - https://github.com/atif-1402/parse

Termai - Created a Simple AI agent in Bash

atif-1402 — Thu, 24 Sep 2026 04:06:40 +0000

No Python. No Node. Just Bash and jq.

an AI assistant that runs in your terminal, chats with an LLM, and can search the web, check the weather, fetch URLs and run commands.

Tool calling turned out to be just a case statement: the model picks a tool, Bash runs it, the result goes back to the model.

DEV Community: atif-1402

Which Copy Do I Keep? Sloth-Powered Folder Tidying with a Local Gemma

What I Built

If you disagree with it

Demo

Code

atif-1402 / keeper

Which file do I keep? Finds version-clone files in a folder and asks a local open-weight model (Ollama + Gemma) which copy wins — and why. Dry-run by default, never deletes, fully reversible.

Demo

Why this exists

How I Built It

The safety net

Why Does Open Innovation Matter?

The Lazy Payoff

Prize Categories

I created parse to solve the problem of messy cli outputs

Termai - Created a Simple AI agent in Bash