tomevault-io Lattice Search Skill
Overview
The Fold's lattice is a DAG of verified skills with comprehensive meta-tooling for discovery and navigation. This skill provides search, inspection, and cross-reference capabilities.
Use lattice search for:
- Finding functions by name, description, or type signature
- Exploring skill dependencies and dependents
- Understanding what a skill exports
- Tracing call graphs (what calls what)
- Discovering capabilities you didn't know existed
Quick Reference
| Command | Purpose | Example |
|---|---|---|
lf |
Full-text search (BM25 ranked) | (lf "matrix decomposition") |
lfe |
Exact symbol lookup | (lfe 'vec3) |
lfp |
Prefix search | (lfp 'matrix) |
lfs |
Substring search | (lfs 'c2d) |
li |
Skill description | (li 'linalg) |
le |
List exports | (le 'linalg) |
lm |
List modules | (lm 'linalg) |
ld |
Dependencies (what it needs) | (ld 'physics/diff) |
lu |
Dependents (what uses it) | (lu 'linalg) |
lxu |
Callers (what calls this) | (lxu 'matrix-rows) |
lxc |
Callees (what this calls) | (lxc 'floyd-warshall) |
ls |
Lattice statistics | (ls) |
Instructions
Basic Search
# Full-text search - finds functions, skills, descriptions
./fold "(lf \"parser combinator\")"
# Exact symbol lookup (falls back to substring if not found)
./fold "(lfe 'maybe-bind)"
# Prefix search - finds all symbols starting with prefix
./fold "(lfp 'matrix)" # matrix-*, matrix-multiply, etc.
# Substring search - finds symbols containing substring
./fold "(lfs 'zoh)" # finds c2d-zoh, d2c-zoh, etc.
# Autocomplete suggestions
./fold "(lattice-complete \"mat\")"
Type-Aware Search (Hoogle-style)
# Find functions with type in signature
./fold "(lf-type \"Monad\")"
# Find functions that take a specific type as input
./fold "(lf-input \"Matrix\")"
# Find functions that return a specific type
./fold "(lf-output \"Maybe\")"
Cross-Reference Queries
# Build the cross-reference cache first (only needed once per session)
./fold -s dev "(build-xref-cache!)"
# What functions call this?
./fold -s dev "(lxu 'matrix-rows)"
# What does this function call?
./fold -s dev "(lxc 'floyd-warshall)"
# All transitive callers
./fold -s dev "(xref-callers-transitive 'fn)"
# Most-called functions (hot spots)
./fold -s dev "(xref-most-called 10)"
DAG Navigation
# What does this skill depend on?
./fold "(ld 'physics/diff)"
# What skills use this one?
./fold "(lu 'linalg)"
# Find path between skills
./fold "(lattice-path 'physics/diff 'linalg)"
# Tier 0 skills (foundational, no deps)
./fold "(lattice-roots)"
# Skills with no dependents (leaves)
./fold "(lattice-leaves)"
# Most-depended-on skills (hubs)
./fold "(lattice-hubs)"
Inspection
# Full skill description
./fold "(li 'linalg)"
# List all exports from a skill
./fold "(le 'linalg)"
# List modules with descriptions
./fold "(lm 'linalg)"
# One-line summary of all skills
./fold "(lattice-summary)"
# Structured data for programmatic use
./fold "(lattice-info 'linalg)"
Analytics & Health
# Lattice statistics
./fold "(ls)"
# Health check (missing deps, cycles)
./fold "(lh)"
# Metadata coverage report
./fold "(lattice-coverage-pretty)"
# Print full DAG structure
./fold "(lattice-graph)"
Manifest Auditing
# Find missing/phantom exports in a skill
./fold "(audit-skill-pretty 'fp)"
# List exports to add to manifest
./fold "(suggest-missing 'fp)"
Search Best Practices
- Start broad, then narrow: Use
(lf "concept")first, then(lfe 'symbol)for exact matches - Use substring for partial names: If you know part of a name (like
c2d), use(lfs 'c2d) - Try multiple query variations: Function might be named differently than expected
- Check skill exports: Use
(le 'skill-name)to see what a skill actually exports - Not all functions are exported: Use
(audit-skill 'name)to find functions in source but missing from manifests
Examples
Example 1: Finding Matrix Operations
# Start with full-text search
./fold "(lf \"matrix multiplication\")"
# Found 'linalg' skill, check its exports
./fold "(le 'linalg)"
# Get module list to understand structure
./fold "(lm 'linalg)"
Example 2: Exploring a Function's Usage
# Who calls matrix-transpose?
./fold -s dev "(build-xref-cache!)"
./fold -s dev "(lxu 'matrix-transpose)"
# What does the main caller depend on?
./fold -s dev "(lxc 'the-caller-function)"
Example 3: Finding Control System Functions
# Don't know exact name, try substring
./fold "(lfs 'c2d)"
# Returns: c2d-zoh, c2d-tustin, etc.
# Get full info on the skill
./fold "(li 'fp)"
./fold "(le 'fp)"
Example 4: Discovering Capabilities
# What can I do with parsers?
./fold "(lf \"parser\")"
# What monads are available?
./fold "(lf-type \"Monad\")"
# What data structures exist?
./fold "(li 'data)"
./fold "(le 'data)"
Lattice Structure
Tiers are derived from DAG depth (not declared). Use (lattice-depth 'skill-name) to check. Tier 0 = no lattice deps (foundational), higher tiers = more dependencies. Implementation in lattice/meta/dag.ss.
Converted and distributed by TomeVault — claim your Tome and manage your conversions.