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

lf

(lf "matrix decomposition")

lfe

(lfe 'vec3)

lfp

(lfp 'matrix)

lfs

(lfs 'c2d)

li

(li 'linalg)

le

(le 'linalg)

lm

(lm 'linalg)

ld

(ld 'physics/diff)

lu

(lu 'linalg)

lxu

(lxu 'matrix-rows)

lxc

(lxc 'floyd-warshall)

ls

(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

1. Start broad, then narrow: Use

   (lf "concept")

   first, then

   (lfe 'symbol)

   for exact matches
2. Use substring for partial names: If you know part of a name (like

   c2d

   ), use

   (lfs 'c2d)

3. Try multiple query variations: Function might be named differently than expected
4. Check skill exports: Use

   (le 'skill-name)

   to see what a skill actually exports
5. 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

Module Locations

lattice/meta/kg.ss

lattice/meta/bm25.ss

lattice/meta/search.ss

lattice/meta/type-search.ss

lattice/meta/xref.ss

lattice/meta/dag.ss

lattice/meta/inspect.ss

lattice/meta/meta.ss