Cache logo

Cache

CommunityPopular
jeremylongshore
cache

Use when the user wants to view, search, add, edit, prune, archive, or clear hyperflow memory entries. CRUD interface for `.hyperflow/memory/` — never modifies source code, only memory files. Trigger with /hyperflow:cache, "show memory", "search memory for X", "clear memory", "what does hyperflow remember about Y".

Overview

Publisherjeremylongshore
Repositorytons-of-skills-marketplace
Skill namecache
Stars
2.8K
Forks
402
Bundled files
4
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 4 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by jeremylongshore on GitHub. Read the source before you install it.

Installation

Install the Cache AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/jeremylongshore/tons-of-skills-marketplace.git /tmp/tons-of-skills-marketplace
mkdir -p .claude/skills
cp -r /tmp/tons-of-skills-marketplace/plugins/ai-agency/hyperflow/skills/cache .claude/skills/cache
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Cache in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Cache on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Cache is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Cache

CRUD interface for .hyperflow/memory/. Full protocol: memory-system.md.

Storage

All operations target .hyperflow/memory/ at the project root. Never modify source code files — if asked to "remember X about file Y", add a memory entry only, never edit Y.

Subcommands

SubcommandDescription
show [tag]Print index or filter entries by tag
search <query>Full-text search across all memory files
add <category> <title>Append a new entry (prompts for details)
edit <entry-id>Find entry by date+title slug and update in place
pruneRemove stale, superseded, and orphaned entries
archiveMove entries older than 30 days to cold storage
clearWipe all memory (with confirmation, recoverable)
statsCounts, tier breakdown, tag frequency, oldest/newest
migrateImport entries from legacy ~/.claude/hyperflow-memory.md
offDisable memory writes for this session
compactSummarise aged memory entries into stubs + monthly archive sidecars

Subcommand Details

show [tag]

No arg → print index.md. With tag → filter all files for matching entries. Output table: Date | Title | Tags | File | Tier

search <query>

grep/ripgrep across learnings.md, decisions.md, pitfalls.md, patterns.md, conventions.md. Return file:line + snippet, ranked by relevance.

add <category> <title>

Categories: learning decision pitfall pattern convention Prompt via AskUserQuestion for: what, why it matters, tags (controlled vocab). Append to the matching file using:

### [YYYY-MM-DD] <title>  `[tag1, tag2]`
**What:** ...
**Why it matters:** ...
**Evidence:** ...

That is the whole write. index.md is derived — scripts/memory-index.py rebuilds it at the next session start. Never append index rows by hand; to refresh it now, run python3 scripts/memory-index.py .hyperflow.

edit <entry-id>

Locate by date+title slug. Show current value, prompt for new value, update in place.

prune

Per memory-system.md pruning protocol:

  • Remove [SUPERSEDED] entries older than 7 days
  • Remove entries whose referenced files no longer exist (test -f)
  • Archive entries unreferenced 90+ days to .hyperflow/memory/archive/YYYY-MM.md Print summary of removed/archived counts.

archive

Compress hot entries older than 30 days → .hyperflow/memory/archive/YYYY-MM.md. Leave one-line summary in original file. The stub keeps its date, so the derived index re-tiers it to cold on its own.

clear

Confirm via AskUserQuestion: "This wipes all memory for this project. Are you sure?" If yes → move all content to .hyperflow/memory/archive/cleared-<timestamp>.md, then reset files to empty stubs.

stats

Print: total entries, hot/warm/cold counts, tag frequency table, oldest and newest entry dates.

migrate

Read ~/.claude/hyperflow-memory.md, filter entries matching current project path. Append matching entries to learnings.md. Leave legacy file untouched. Print count of migrated entries.

off

Print: "Memory writes disabled for this session." No files modified.

compact

User-invoked memory compaction. Summarises entries older than 7 days into stub lines and preserves the full text in monthly archive sidecars at .hyperflow/memory/archive/YYYY-MM.md.

Flow:

  1. The compact subcommand handler reads the target memory file (default: learnings.md; pass a path to target another).
  2. The Date/tag parser splits entries into hot (≤7 days, preserved) and eligible (>7 days). Both [domain, type] and legacy backticked `[domain, type]` tag forms are accepted.
  3. The Compaction Writer is dispatched in a single batch with all eligible entries.
  4. The Stub formatter renders each replacement line as ### [YYYY-MM-DD] Short title [domain, type] — summarized, see archive/YYYY-MM.md.
  5. The Dedup Reviewer performs source-side stub-line match and archive-side header match (date + title + tags on both sides) to prevent duplicates.
  6. The Archive-sidecar writer appends accepted entries to archive/YYYY-MM.md, grouped by each entry's calendar month.
  7. The source file is rewritten with stubs replacing the original entries.
  8. The compact subcommand handler refreshes .hyperflow/memory/.checksums (a memory-scoped sidecar — distinct from .hyperflow/.checksums which the scaffold staleness check owns) and exits with a summary.

Output: N entries compacted into archive/YYYY-MM.md · M stubs rejected as duplicates · source N→M lines. Full protocol in compaction.md.

Flow

  1. Parse invocation to determine subcommand
  2. If subcommand missing → list subcommands table above with one-line descriptions
  3. Execute subcommand
  4. Print structured result with counts/changes summary

Overview

/hyperflow:cache is the operator interface to project-scoped memory under .hyperflow/memory/. It's the only skill that mutates memory files directly (other skills append via the memory-system protocol). Subcommands cover the full lifecycle: show, search, add, edit, prune, archive, clear, stats, migrate. All operations are project-local — entries never leak across projects.

Prerequisites

  • .hyperflow/ initialized (run /hyperflow:scaffold if missing — cache creates .hyperflow/memory/ on first write but expects the parent dir).
  • Write access to .hyperflow/memory/ and .hyperflow/memory/archive/.
  • For migrate only: read access to ~/.claude/hyperflow-memory.md (legacy global memory).

Instructions

See Subcommands and Subcommand Details above for the full operational spec. Summary:

  1. Parse the subcommand from the user's invocation (or list subcommands if none given).
  2. Validate prerequisites for the chosen subcommand (e.g. clear requires AskUserQuestion confirmation; migrate requires legacy file presence).
  3. Execute the subcommand against .hyperflow/memory/.
  4. Print structured result with counts and any file-level changes.

Output

Each subcommand prints a compact summary:

  • show — table of matching entries (Date | Title | Tags | File | Tier).
  • searchfile:line matches with snippets, ranked by relevance.
  • add / edit — confirmation line with new entry id and target file.
  • prune / archive / clear — counts of removed/archived/cleared entries plus destination paths.
  • stats — totals + hot/warm/cold breakdown + top-N tags.
  • migrate — count of migrated entries + source legacy file path.
  • off — single-line Memory writes disabled for this session.

Error Handling

FailureBehavior
.hyperflow/memory/ missingAuto-create skeleton (index.md + 5 category files + archive/.gitkeep) on first write; for read-only subcommands, print (no memory yet — invoke /hyperflow:scaffold first).
Subcommand unknownPrint subcommands table; suggest closest match via Levenshtein distance.
add with invalid categoryReject and list valid categories: learning, decision, pitfall, pattern, convention.
edit entry id not foundList 3 closest matches by title slug + date.
clear without confirmation (headless)Refuse and print clear requires interactive confirmation. Do not wipe.
migrate source file missingPrint (nothing to migrate — ~/.claude/hyperflow-memory.md not found) and stop.

Examples

Show all entries

/hyperflow:cache show

Date         Title                              Tags                  File              Tier
2026-05-16   Bash scoping required by validator [validator, marketplace] learnings.md   hot
2026-05-15   No AI attribution in commits       [convention, git]     conventions.md    hot
2026-05-14   Per-task commits in plugin dev     [convention, git]     conventions.md    hot
3 entries (3 hot, 0 warm, 0 cold)

Search

/hyperflow:cache search "validator"

.hyperflow/memory/learnings.md:42 — "Jeremy's validator requires scoped Bash..."
.hyperflow/memory/decisions.md:8 — "...validator score of 73 → 94 after fix"
2 matches

Add a learning

/hyperflow:cache add learning "Markdown frontmatter needs block scalar for colons"

? What: Block scalar (|) preserves : and backticks in YAML values
? Why it matters: prevents fatal YAML parse failures in marketplace validators
? Tags: yaml, validator, frontmatter
Added — .hyperflow/memory/learnings.md (entry 2026-05-16-block-scalar-frontmatter)

Stats

/hyperflow:cache stats

Memory entries: 47
  Hot   (≤7d)   12
  Warm  (8-30d) 23
  Cold  (30d+)  12
Top tags: validator (8), convention (7), git (6), yaml (4)
Oldest: 2026-02-14   Newest: 2026-05-16

Resources

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Cache AI skill do?

Use when the user wants to view, search, add, edit, prune, archive, or clear hyperflow memory entries. CRUD interface for `.hyperflow/memory/` — never modifies source code, only memory files. Trigger with /hyperflow:cache, "show memory", "search memory for X", "clear memory", "what does hyperflow remember about Y".

Why use Cache on TypingMind?

Because you install it once and use it with any model. Cache is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Cache in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/jeremylongshore/tons-of-skills-marketplace/tree/main/plugins/ai-agency/hyperflow/skills/cache. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Cache?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Cache?

As many as you like. As long as a model supports skills, you can use Cache with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Cache AI skill free?

Yes. It is published on GitHub by jeremylongshore under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇