{"slug": "show-hn-deja-predicts-your-next-shell-command-without-an-llm", "title": "Show HN: Deja predicts your next shell command without an LLM", "summary": "Giammarco-Ferranti released Deja, an open-source zsh plugin that predicts shell commands using fuzzy matching, directory awareness, and sequence prediction, without relying on an LLM. The tool runs as a local daemon with sub-millisecond response times and stores all data in a local SQLite database, offering a faster, privacy-preserving alternative to zsh-autosuggestions.", "body_md": "Deja is a smarter replacement for [`zsh-autosuggestions`](https://github.com/zsh-users/zsh-autosuggestions). Instead of only surfacing commands that start with what you've typed, Deja uses **fuzzy matching**, **directory awareness**, and **command sequence prediction** to suggest what you actually want to run — as inline ghost text, after every keystroke, with zero latency.\n\nNo account. No sync server. No TUI. Just ghost text that knows where you are.\n\n- **Fuzzy matching** — suggests commands even when you skip letters or mix up order\n- **Directory awareness** — commands you run in`~/projects/foo` rank higher when you're in`~/projects/foo`\n- **Sequence prediction** — knows that you usually run`make test` after`make build`\n- **Frecency scoring** — blends frequency + recency with a 1-week exponential decay\n- **Ghost text inline** — uses zsh's`POSTDISPLAY` widget, not a separate pane\n- **Daemon architecture** — one lightweight background process serves all terminal windows;`<1ms` response per keystroke\n- **Local-only** — all data stays in a local SQLite database; nothing leaves your machine\n- **Respects your history settings** — a leading space (`HIST_IGNORE_SPACE` ) or a`HISTORY_IGNORE` match keeps a command out of deja too, not just out of`~/.zsh_history`\n- **Alternatives picker** — press`Tab` to cycle through ranked alternatives without leaving the line\n\n```\nbrew install Giammarco-Ferranti/deja/deja && deja import && (grep -qF 'deja/init.zsh' ~/.zshrc 2>/dev/null || echo 'if [[ -r \"$HOME/.local/share/deja/init.zsh\" ]]; then source \"$HOME/.local/share/deja/init.zsh\"; else eval \"$(deja init zsh)\"; fi' >> ~/.zshrc) && exec zsh\ncurl -fsSL https://raw.githubusercontent.com/Giammarco-Ferranti/deja/main/install.sh | sh\n```\n\nBoth commands install deja, import your existing zsh history, add the integration to `~/.zshrc` (idempotent), and reload your shell. To audit the curl installer before running it, [view it on GitHub](https://github.com/Giammarco-Ferranti/deja/blob/main/install.sh).\n\nIf you manage zsh with [Oh My Zsh](https://ohmyz.sh), enable deja the idiomatic way, the same flow as `zsh-autosuggestions`. The binary still comes from Homebrew or the curl script; the plugin just sources deja's integration for you.\n\n```\n# 1. Install the deja binary. Skip (or remove) the activation lines it offers to\n#    add to ~/.zshrc, since the plugin loads the integration for you:\nbrew install Giammarco-Ferranti/deja/deja          # or the curl installer above\n\n# 2. Clone the plugin into Oh My Zsh's custom plugins dir:\ngit clone https://github.com/Giammarco-Ferranti/deja \\\n  ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/deja\n\n# 3. Add `deja` to plugins=(...) in ~/.zshrc:\n#      plugins=( ... deja )\n\n# 4. Import your history once and reload:\ndeja import && exec zsh\n```\n\nIf you use [zinit](https://github.com/zdharma-continuum/zinit), add this to your `.zshrc`:\n\n```\nzinit ice wait\"0\" lucid depth=1 pick\"deja.plugin.zsh\"\nzinit light Giammarco-Ferranti/deja\n```\n\nzinit handles the Oh My Zsh plugin integration, so the activation lines in `~/.zshrc` are not needed. Make sure the `deja` binary is installed separately via Homebrew or the curl installer.\n\nPrefer not to clone the whole repo? Fetch just the plugin file instead:\n\n```\nmkdir -p ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/deja\ncurl -fsSL https://raw.githubusercontent.com/Giammarco-Ferranti/deja/main/deja.plugin.zsh \\\n  -o ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/deja/deja.plugin.zsh\n```\n\n**Pick one activation, not both.** The plugin loads deja's integration for you, so if the installer already appended activation lines to `~/.zshrc`, remove them. Keeping both double-sources the integration.\n\nDeja replaces `zsh-autosuggestions`, so don't list both in `plugins=()`. If deja detects `zsh-autosuggestions` is loaded it stands down (see [Troubleshooting](#troubleshooting)).\n\nThe install commands above already do this for you. If you skipped them and have the binary on `$PATH` some other way, run these once to import your zsh history and activate the integration:\n\n``` python\ndeja import\neval \"$(deja init zsh)\"\n```\n\nBy default `deja import` reads your zsh history from `$HISTFILE` (when it's\nexported), falling back to `~/.zsh_history`. If your history lives elsewhere\nor `$HISTFILE` is set in `~/.zshrc` without `export`, so child processes can't\nsee it point deja at the file explicitly:\n\n```\ndeja import --file /path/to/history\n```\n\nTo make it permanent, add this to your `~/.zshrc`:\n\n```\n# ~/.zshrc\nif [[ -r \"$HOME/.local/share/deja/init.zsh\" ]]; then\n  source \"$HOME/.local/share/deja/init.zsh\"\nelse\n  eval \"$(deja init zsh)\"\nfi\n```\n\n`deja init zsh` does not print the integration script — it *writes* it to\n`~/.local/share/deja/init.zsh` and prints a `source` line for that file. So\n`eval \"$(deja init zsh)\"` spends a full binary launch, ~25–36 ms on every shell\nyou open, regenerating a file that is almost always byte-identical. Sourcing the\nfile directly skips that; the `eval` above is only the first-run bootstrap, for\nbefore the file exists.\n\nDeja keeps the cached script current itself. Each shell compares the installed binary's stat identity against the one baked into the script — 0.083 ms, no subprocess — and if they differ, regenerates it in the background. The shell that noticed carries on with the old script; the next one picks up the new. So an upgrade never costs you a slow shell startup, and never leaves you on a stale integration either.\n\nDeja auto-spawns its daemon on first use and keeps it running across sessions.\n\n| Key | Action | Rebind with | \n|---|---|---|\n| `→` (right arrow) | Accept full suggestion | `DEJA_ACCEPT_KEY` (extra key) | \n| `Ctrl+→` | Accept next word only | `DEJA_WORD_ACCEPT_KEY` (extra key) | \n| `Shift+→` | Cycle fuzzy preset forward (tight → smart → loose) | `DEJA_CYCLE_FUZZY_KEY` | \n| `Shift+←` | Cycle fuzzy preset backward (loose → smart → tight) | `DEJA_CYCLE_FUZZY_BACK_KEY` | \n| `Shift+↑` | Toggle ghost text on an empty prompt (persisted, global) | `DEJA_TOGGLE_EMPTY_KEY` | \n| `Tab` | Open inline alternatives picker | `DEJA_CYCLE_KEY` | \n| `Ctrl+X` | Suppress current suggestion (session-wide) | `DEJA_TOGGLE_KEY` | \n| *(unbound)* | Dismiss the current ghost (this line only) | `DEJA_DISMISS_KEY` | \n\nAccept the ghost suggestion with `→`, not `Enter`. `Enter` executes whatever's literally in your buffer; `→` is what commits the ghost into the buffer first.\n\nEvery binding above can be remapped by exporting the matching env var **before** the lines that load deja in your `~/.zshrc`. Values are zle key sequences (e.g. `^I` is Tab, `^X` is Ctrl+X, `^[[1;2C` is Shift+→); run `bindkey -L` or pipe a keypress through `cat -v` to discover a key's sequence. Set any var to empty to leave that key unbound.\n\n```\n# defaults\nexport DEJA_CYCLE_KEY='^I'                 # Tab     → cycle alternatives\nexport DEJA_TOGGLE_KEY='^X'                # Ctrl+X  → suppress for the session\nexport DEJA_CYCLE_FUZZY_KEY='^[[1;2C'      # Shift+→ → next fuzzy preset\nexport DEJA_CYCLE_FUZZY_BACK_KEY='^[[1;2D' # Shift+← → previous fuzzy preset\nexport DEJA_TOGGLE_EMPTY_KEY='^[[1;2A'     # Shift+↑ → flip empty-prompt suggestions\n# these are unbound by default (→ and Ctrl+→ already accept via wrapped widgets):\nexport DEJA_ACCEPT_KEY=       # accept full suggestion on a dedicated key\nexport DEJA_WORD_ACCEPT_KEY=  # accept the next word on a dedicated key\nexport DEJA_DISMISS_KEY=      # clear the ghost for this line (unlike Ctrl+X, the session keeps suggesting)\n```\n\n`DEJA_DISMISS_KEY` (`deja-clear`) differs from `DEJA_TOGGLE_KEY` (`deja-toggle`): dismiss only wipes the ghost on the current line, while toggle suppresses suggestions for the whole session until you toggle back or start a new shell.\n\nExamples:\n\n```\n# Use Tab to accept the suggestion (and free Tab from cycling):\nexport DEJA_ACCEPT_KEY='^I' DEJA_CYCLE_KEY=\n\n# Move alternatives-cycling off Tab so fzf/native completion keeps it:\nexport DEJA_CYCLE_KEY='^N'\n```\n\n**Esc as dismiss:** binding `DEJA_DISMISS_KEY='^['` (Esc) directly is discouraged — Esc is the prefix byte for arrow keys, function keys, and vi-mode, so a bare `^[` binding can break those. Prefer a non-prefix key (e.g. `^G`), or set it knowing the tradeoff.\n\nDeja paints its suggestion through zsh's `region_highlight`, so the ghost text accepts any style string zsh understands. The default is `fg=8` (ANSI bright black), which renders as dim grey on most themes.\n\n```\nexport DEJA_HIGHLIGHT_STYLE='fg=cyan'\n```\n\nThe grammar is the same one `zsh-autosuggestions` uses for `ZSH_AUTOSUGGEST_HIGHLIGHT_STYLE`, so an existing style carries over unchanged:\n\n| Value | Effect | \n|---|---|\n| `fg=8` | dim grey, the default | \n| `fg=cyan` | named colour | \n| `fg=244` | index into the 256 colour palette | \n| `fg=cyan,bg=white` | foreground plus background | \n| `fg=cyan,bold,underline` | attributes; `standout` and`blink` also work | \n\n**Export it before the integration loads.** The variable is read once, at the moment the init script is sourced, and it only applies when already unset. Setting it below the `source` line in `~/.zshrc` has no effect, so put it above:\n\n```\n# ~/.zshrc\nexport DEJA_HIGHLIGHT_STYLE='fg=cyan,bold'   # must come first\n\nif [[ -r \"$HOME/.local/share/deja/init.zsh\" ]]; then\n  source \"$HOME/.local/share/deja/init.zsh\"\nelse\n  eval \"$(deja init zsh)\"\nfi\n```\n\nIf the default is too faint on your colour scheme, `fg=244` or `fg=8,bold` usually lifts it clear of the background without competing with the text you are typing.\n\nDeja's matcher accepts any in-order subsequence of the characters you've typed. By default it stops the typed letters from sprawling too far apart in a candidate — `gco` will match `git checkout`, but won't match `git remote add origin`. Pick a preset to tune that strictness:\n\n| Preset | Behavior | Example: typing `gco` | \n|---|---|---|\n| `loose` | typed letters can be far apart (up to 8 chars between) | `gco` →`git checkout -- README` | \n| `smart` | typed letters stay close together (up to 4 chars between) — **default** | `gco` →`git checkout main` | \n| `tight` | typed letters must be near-adjacent (up to 1 char between) | `gco` →`gco` ,`g.co` ,`gc.o` | \n\nChange the preset on the fly (takes effect immediately, persists across restarts):\n\n```\ndeja fuzzy           # show current preset + examples\ndeja fuzzy tight     # set the preset\ndeja fuzzy cycle     # advance to the next preset  (tight → smart → loose → tight)\ndeja fuzzy back      # step to the previous preset (loose → smart → tight → loose)\n```\n\nOr cycle without leaving the line — press `Shift+→` (forward) or `Shift+←` (backward) at any prompt and the next preset is applied immediately. The ghost suggestion repaints under the new mode in the same frame, and a picker-style confirmation appears below the prompt showing where you are in the ladder:\n\n```\ndeja: fuzzy    tight    *smart*    loose\n```\n\nRebind via `DEJA_CYCLE_FUZZY_KEY` / `DEJA_CYCLE_FUZZY_BACK_KEY` (set either to empty to disable that direction; tmux users may need `set -g xterm-keys on` for the default Shift+arrow sequences to pass through).\n\nOr override per shell session via environment variable:\n\n```\nexport DEJA_FUZZY=smart   # before the daemon starts; takes precedence over the saved preset\n```\n\nBy default, on a fresh prompt — before you've typed anything — Deja predicts the command you're most likely to run next, based on command-sequence, frecency, and directory signals, and shows it as ghost text. If you'd rather see nothing until you start typing, turn empty-prompt suggestions off:\n\n```\ndeja empty            # show whether empty-prompt suggestions are on\ndeja empty off        # never suggest on an empty prompt (aliases: deja empty hide)\ndeja empty on         # restore the default (aliases: deja empty show)\ndeja empty toggle     # flip the setting, printing just the new state (on|off)\n```\n\nOr flip it without leaving the line — press `Shift+↑` at any prompt. The ghost appears or disappears in the same frame, and a picker-style confirmation shows the new state below the prompt:\n\n```\ndeja: empty   *on*    off\n```\n\nRebind via `DEJA_TOGGLE_EMPTY_KEY` (set it to empty to leave `Shift+↑` unbound; tmux users may need `set -g xterm-keys on` for the default Shift+arrow sequences to pass through). Note that — like fuzzy cycling — the keypress changes the persisted, global setting, not just the current session.\n\nChanges take effect immediately if the daemon is running and persist across restarts (saved to `~/.local/share/deja/config`). Override per shell session with an environment variable:\n\n```\nexport DEJA_EMPTY=off   # before the daemon starts; takes precedence over the saved setting\n```\n\nThis is a **global, persisted** setting. It's different from `Ctrl+X`, which suppresses **all** suggestions for the current shell session only (see [Key Bindings](#key-bindings)).\n\nDeja records the commands you run, so it honours the same rules zsh uses to decide what *not* to remember. If zsh won't keep a command, deja won't either.\n\n**Keep one command out of history with a leading space.** With `setopt hist_ignore_space` (set it in `~/.zshrc`; some frameworks enable it by default), any line starting with a space or tab is discarded by zsh. Deja skips it too:\n\n```\nsetopt hist_ignore_space\n export AWS_SECRET_ACCESS_KEY=wJal…   # leading space: neither zsh nor deja records this\n```\n\nThe check runs inside the shell hook, before deja is invoked, so the command is never handed to another process and never appears in `ps`.\n\n**Keep a pattern out of history with `HISTORY_IGNORE`.** Deja applies your pattern the way zsh does, as a glob against the whole line:\n\n```\nHISTORY_IGNORE='(*AWS_SECRET*|*--password*)'\n```\n\n**Ignored commands break the prediction chain.** A skipped command is also dropped as the \"previous command\" used for sequence prediction, so it can't resurface indirectly through the `sequences` table.\n\n**One deliberate difference from zsh.** Deja drops space-prefixed commands even if you haven't set `hist_ignore_space`, because the daemon can't see your shell's `setopt` state and errs toward forgetting. Those commands stay in your zsh history as usual; they're simply not learned by deja. Suggestions are always offered trimmed, so nothing useful is lost.\n\n**Commands recorded before you upgraded** are still in the database. To start over from your current history:\n\n```\npkill -f 'deja daemon'\nrm ~/.local/share/deja/deja.db\ndeja import\n```\n\n`deja import` applies the same rules, so space-prefixed lines in your history file are skipped.\n\nDeja stores commands in plaintext in a local SQLite database and never sends them anywhere. It does not redact secrets embedded in otherwise ordinary commands such as `curl -H \"Authorization: ...\"`, so use the leading space for those.\n\nEvery subcommand supports `--help` (e.g. `deja query --help`) for flag-level details. The most common issues:\n\n**Suggestions aren't appearing.**\n\n1. Check the daemon is reachable: `deja ping` should print`pong` .\n2. Confirm the integration is loaded in your shell: `~/.zshrc` must source`~/.local/share/deja/init.zsh` (see[Setup](#setup) ) and the shell must have been re-sourced (`exec zsh` ).\n3. `Ctrl+X` toggles per-session suppression — start a new shell to clear it.\n\n**Ghost text is too faint to read.**\nThe suggestion is painted `fg=8` (dim grey) by default, which some terminal themes render almost invisibly. Choose a brighter style with `DEJA_HIGHLIGHT_STYLE`, exported above the `source` line in `~/.zshrc`. See [Ghost text appearance](#ghost-text-appearance).\n\n**Using another inline-suggestion plugin.**\nDeja renders its own ghost text and replaces `zsh-autosuggestions` — don't run both. If Deja detects `zsh-autosuggestions` is loaded it prints a one-line notice and stands down (rather than wrapping the same ZLE widgets, which can wedge the line editor). To use Deja, remove `zsh-autosuggestions` from `plugins=()` in `~/.zshrc` and restart your shell.\n\n**The daemon seems stuck.**\n\n```\ndeja daemon --restart\n```\n\nOr stop it and let a fresh terminal auto-respawn it via the init script:\n\n```\npkill -f 'deja daemon'\n```\n\n**Suggestions still work but feel slow after upgrading deja.**\nDaemons outlive shell sessions, so the one still running is from the previous\nversion. New shells detect this and fall back to a slower path that keeps\nworking; `deja daemon --restart` replaces it. Upgrading from a version older\nthan the one that introduced `--restart` needs a one-time `pkill -f 'deja daemon'` instead, since those daemons left no pidfile to find them by.\n\n**Stale socket after a crash.**\n\n```\nrm ~/.local/share/deja/sock\n```\n\nThen open a new shell.\n\n**Reset the database (start over from current `~/.zsh_history`).**\n\n```\npkill -f 'deja daemon'\nrm ~/.local/share/deja/deja.db\ndeja import\n```\n\n**Where data lives.**\n\n| Path | Purpose | \n|---|---|\n| `~/.local/share/deja/deja.db` | SQLite database (history, stats, sequences) | \n| `~/.local/share/deja/sock` | Unix socket the daemon listens on | \n| `~/.local/share/deja/init.zsh` | Generated zsh integration script | \n\nEverything is per-user: each account gets its own database, socket, and daemon under its own `$HOME`. The directory is `0700` and the database files are `0600`, so other local accounts can't read your history. Deja re-applies those modes every time it runs, which repairs installs created by older versions with no action from you.\n\nDeja is built around four signals that are combined into a single composite score:\n\n```\nscore = 1.0 × fuzzy\n      + 0.4 × frecency\n      + 0.3 × directory_affinity\n      + 0.5 × sequence_score\n```\n\n| Signal | What it measures | \n|---|---|\n| **Fuzzy** | Subsequence match quality with bonuses for consecutive characters, word boundaries, and prefix hits | \n| **Frecency** | Log-scaled frequency combined with exponential recency decay (1-week half-life) | \n| **Directory affinity** | How often you've run this command from the current directory | \n| **Sequence score** | Probability that this command follows the one you just ran | \n\nScoring only runs over commands that are plausible continuations of what you typed. If any command in your history starts with the text on the line, only those are considered — typing `cd`  suggests a `cd …` you have actually run, never `claude --resume` just because `c…d…␣` happens to be hiding in it. If nothing starts with the line but its first word is a command you've run, the suggestion stays inside that command, so `git ceckout` still finds `git checkout main`.\n\nFuzzy expansion applies when the text is *not* a command you've run: `gco` → `git checkout` is untouched. The flip side is that an anchored line with nothing to match shows no ghost text at all, rather than an unrelated command.\n\n```\n┌─────────────────┐        Unix socket        ┌──────────────────────┐\n│   zsh widget    │ ──────────────────────▶   │   deja daemon        │\n│  (per keystroke)│ ◀──────────────────────   │  (single process,    │\n└─────────────────┘    suggestion (<1ms)      │   all terminals)     │\n                                              └──────────┬───────────┘\n                                                         │\n                                                   SQLite (WAL)\n                                              commands · stats · seqs\n```\n\nThe daemon loads all state into memory at startup (`map[string]*CommandStat`, directory affinities, sequence pairs) and uses a `sync.RWMutex` so reads never block each other. Writes (command recording) take microseconds.\n\nIf the daemon is unavailable, `deja query` falls back to a direct SQLite read automatically. That path ranks in two passes — once on fuzzy, frecency and sequence signal, then again over the top 50 with directory affinities fetched just for them — so a keystroke costs a few queries rather than one per command in your history.\n\n```\ngit clone https://github.com/Giammarco-Ferranti/deja.git\ncd deja\nmake build        # produces ./bin/deja\n\ngo test ./...     # run all tests\ngo vet ./...      # lint\n```\n\nReleases are automated via [release-please](https://github.com/googleapis/release-please) and driven by [conventional commits](https://www.conventionalcommits.org/) on `main`:\n\n- `feat: ...` → minor bump\n- `fix: ...` → patch bump\n- `feat!: ...` or a`BREAKING CHANGE:` footer → major bump\n- `chore:` ,`docs:` ,`test:` ,`refactor:` → no version bump\n\nAfter qualifying commits land on `main`, the `release-please` workflow opens (and keeps updating) a **Release PR** that bumps `.release-please-manifest.json` and updates `CHANGELOG.md`. **Merging that PR is the release action** — it creates the `vX.Y.Z` git tag, which triggers `release.yml` to run the test suite and (only on green) publish binaries via GoReleaser and update the [Homebrew tap](https://github.com/Giammarco-Ferranti/homebrew-deja).\n\nMaintainers should not run `git tag` manually.\n\nContributions are welcome — see [CONTRIBUTING.md](/Giammarco-Ferranti/deja/blob/main/CONTRIBUTING.md) for setup, workflow, and commit conventions. For anything larger than a small fix, please open an issue first so we can align on direction.\n\nThe scorer (`internal/scorer/`) is the most iteration-heavy part of the codebase — the four signal weights are the best place to experiment if you want to improve suggestion quality.\n\nPlease report vulnerabilities privately via GitHub's \"Report a vulnerability\" button on the repo's Security tab, not as public issues.\n\nYour command history is stored in plaintext in a local SQLite database. Deja keeps `~/.local/share/deja/` at `0700` and the database files at `0600` so other accounts on the same machine cannot read it (see [Where data lives](#troubleshooting)). It is not encrypted at rest, so anyone who can already act as you, or as root, can read it.\nFor how deja handles sensitive commands, and how to keep one out of the database, see [Privacy](#privacy).\n\n1. Remove the activation lines from `~/.zshrc` — whichever form you used:\n\n```\nif [[ -r \"$HOME/.local/share/deja/init.zsh\" ]]; then\n  source \"$HOME/.local/share/deja/init.zsh\"\nelse\n  eval \"$(deja init zsh)\"\nfi\n```\n\n2. Stop the running daemon:\n\n```\npkill -f 'deja daemon'\n```\n\n3. Delete local data (history DB, socket, generated init script):\n\n```\nrm -rf ~/.local/share/deja/\n```\n\n4. Remove the binary, depending on how you installed it:\n  - **Homebrew:**`brew uninstall deja` (and optionally`brew untap Giammarco-Ferranti/deja` )\n  - **curl installer:**`rm \"$(which deja)\"` (default location is`~/.local/bin/deja` )\n\nMIT — see [LICENSE](/Giammarco-Ferranti/deja/blob/main/LICENSE).\n\n<sub>Made with ☕ and a friendly ghost.</sub>", "url": "https://wpnews.pro/news/show-hn-deja-predicts-your-next-shell-command-without-an-llm", "canonical_source": "https://github.com/Giammarco-Ferranti/deja", "published_at": "2026-09-08 11:43:36+00:00", "updated_at": "2026-09-08 12:03:19.423187+00:00", "lang": "en", "topics": ["developer-tools", "ai-tools"], "entities": ["Giammarco-Ferranti", "Deja", "zsh-autosuggestions", "Oh My Zsh", "zinit", "Homebrew", "SQLite"], "alternates": {"html": "https://wpnews.pro/news/show-hn-deja-predicts-your-next-shell-command-without-an-llm", "markdown": "https://wpnews.pro/news/show-hn-deja-predicts-your-next-shell-command-without-an-llm.md", "text": "https://wpnews.pro/news/show-hn-deja-predicts-your-next-shell-command-without-an-llm.txt", "jsonld": "https://wpnews.pro/news/show-hn-deja-predicts-your-next-shell-command-without-an-llm.jsonld"}}