Utilities API

remove_chapter!(sst::SSTConnection, chapter::String)

Delete all nodes and links belonging to a chapter from the database. This is a destructive operation that cannot be undone.

browse_notes(sst::SSTConnection, chapter::String;
             page::Int=1, width::Int=SCREENWIDTH) -> String

Format notes from a chapter for terminal display. Retrieves the page map for the given chapter and renders each note with its context, chapter heading, and linked content.

Returns a formatted string suitable for terminal output.

import_json!(sst::SSTConnection, json_str::String;
             chapter::String="json_import") -> Vector{Node}

Import a JSON structure as SST nodes and links. Each key-value pair in the JSON becomes a node (key) with a CONTAINS link to its value node(s). Nested objects create nested containment structures. Arrays create multiple CONTAINS links from the parent key.

Returns a vector of all created nodes.

reset_session_tracking!()

Reset all in-memory session tracking state.

update_last_saw_section!(store::AbstractSSTStore, name::AbstractString)

Record that the given section was accessed at the current time.

update_last_saw_nptr!(store::AbstractSSTStore, nptr::NodePtr, name::AbstractString)

Record that the given node pointer was accessed at the current time.

get_last_saw_section(store::AbstractSSTStore) -> Vector{LastSeen}

Return all tracked sections, sorted by section name, with updated ndelta.

get_last_saw_nptr(store::AbstractSSTStore, nptr::NodePtr) -> LastSeen

Return the LastSeen record for a specific node pointer. Returns a default LastSeen if not tracked.

get_newly_seen_nptrs(store::AbstractSSTStore, horizon::Int) -> Set{NodePtr}

Return the set of node pointers that were last seen within horizon hours. If horizon <= 0, returns all tracked node pointers.

Format text for terminal display with word-wrapping.

Create indentation string of given width.

Print a node orbit to terminal.

Print links of a specific STtype from orbit satellites.

Print a link path from a cone.

Show context summary.

Print STtype index as human-readable string.

Format human-readable time duration.

Expand dynamic function expressions in text (e.g., Dynamic:{TimeUntil Day5}).

Evaluate a built-in function starting at pos (the '{' character).

Dispatch built-in function by name.

Calculate time until a semantic time specification.

Calculate time since a semantic time specification.

Get all arrows matching a name (exact or fuzzy via lowercase comparison).

Get all arrows of a specific STtype.

Get arrow with its name and STtype.

Find next link arrow in a path matching given arrow constraints.

Incrementally expand constrained cone links.

Get singleton nodes by STtype (sources have outgoing but no incoming, sinks vice versa).

Get sequence containers (stories) from node pointers.

Check if a string was already seen in a cone structure.

connect!(store, from, arrow, to; context=String[], weight=1.0f0)

Convenience alias for mem_edge! with keyword arguments.

Example

connect!(store, apple, "contains", fruit)
connect!(store, apple, "note", description; context=["botany"])

links(node::Node) -> Vector{Link}

Get all links from a node, flattened across all ST types.

links(node::Node, sttype::STType) -> Vector{Link}

Get links from a node for a specific ST type.

Example

fwd_links = links(node, LEADSTO)      # Forward causal links
contains = links(node, CONTAINS)      # Containment links
similar = links(node, NEAR)           # Similarity links

neighbors(store::MemoryStore, node::Node) -> Vector{Node}

Get all nodes directly connected to this node.

neighbors(store::MemoryStore, node::Node, sttype::STType) -> Vector{Node}

Get nodes connected via a specific ST type.

nodes(store::MemoryStore) -> Vector{Node}

Get all nodes in the store as a vector.

eachnode(store::MemoryStore)

Iterate over all nodes in the store.

Example

for node in eachnode(store)
    println(node.s)
end

eachlink(node::Node)

Iterate over all links from a node (across all ST types).

Example

for link in eachlink(node)
    println("Arrow: $(link.arr), Dst: $(link.dst)")
end

eachlink(node::Node, sttype::STType)

Iterate over links of a specific ST type.

find_nodes(store::MemoryStore, predicate::Function) -> Vector{Node}

Find all nodes matching a predicate.

Examples

# Find long text nodes
long_nodes = find_nodes(store, n -> n.l > 100)

# Find nodes in a chapter
ch_nodes = find_nodes(store, n -> n.chap == "vocabulary")

find_nodes(store::MemoryStore, pattern::Regex) -> Vector{Node}

Find all nodes whose text matches a regex pattern.

Example

fruit_nodes = find_nodes(store, r"fruit|apple|banana"i)

map_nodes(f::Function, store::MemoryStore) -> Vector

Apply a function to each node and collect results.

Example

names = map_nodes(n -> n.s, store)

with_store(f::Function) -> MemoryStore
with_store(f::Function, store::MemoryStore) -> MemoryStore

Execute a function with a MemoryStore, using do-block syntax.

Example

store = with_store() do s
    a = mem_vertex!(s, "apple", "fruits")
    b = mem_vertex!(s, "banana", "fruits")
    mem_edge!(s, a, "contains", b)
end

with_config(f::Function, config_dir::String)

Execute a function after loading SST arrow configuration.

Example

with_config("/path/to/SSTconfig") do
    result = parse_n4l("-section\n apple (contains) fruit\n")
    @show result
end

SQLIndexConfig

Configuration for indexing a SQL database into SST.

index_sql_database!(store::MemoryStore, db;
                    config::SQLIndexConfig=SQLIndexConfig()) -> Dict{String,Int}

Index a SQL database into the SST graph.

• Each table becomes a chapter (prefixed with config.chapter_prefix)
• Each row becomes a node (labeled by primary key or configured column)
• Foreign key columns create LEADSTO edges between nodes
• Other columns become EXPRESS (note) annotations

Returns a Dict mapping table names to number of nodes created.

validate_compiled_graph!(store::MemoryStore; verbose::Bool=false) -> Vector{String}

Run ETC validation on all nodes in the store. First infers ETC types, then validates them. Returns a flat list of warnings about type mismatches (e.g., a Thing with only LEADSTO links, an Event with no temporal arrows).