@g3nomaly/analyze 0.0.0-stage → 0.1.0

package/dist/model/registry.d.ts

@@ -0,0 +1,494 @@
+import * as z from 'zod/mini';
+/**
+ * The role a node kind plays in the site.
+ * - `section`: a top-level group.
+ * - `folder`: a directory.
+ * - `file`: a file with a page of its own.
+ * - `source`: a source file, a page whose symbols are its entries.
+ * - `symbol`: a declaration in code, shown as an entry.
+ * - `entry`: any other block on the page of its file, with an anchor of its own.
+ * - `member`: a parameter or a field, a row of its entry.
+ */
+export declare const NodeGroupSchema: z.ZodMiniEnum<{
+    entry: "entry";
+    file: "file";
+    folder: "folder";
+    member: "member";
+    section: "section";
+    source: "source";
+    symbol: "symbol";
+}>;
+/** One of the roles of {@link NodeGroupSchema}. */
+export type NodeGroup = z.infer<typeof NodeGroupSchema>;
+/** What the registry states about one node kind. */
+export declare const NodeKindSpecSchema: z.ZodMiniObject<{
+    group: z.ZodMiniEnum<{
+        entry: "entry";
+        file: "file";
+        folder: "folder";
+        member: "member";
+        section: "section";
+        source: "source";
+        symbol: "symbol";
+    }>;
+    label: z.ZodMiniString<string>;
+    description: z.ZodMiniString<string>;
+    letter: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    prose: z.ZodMiniDefault<z.ZodMiniBoolean<boolean>>;
+    typeLike: z.ZodMiniDefault<z.ZodMiniBoolean<boolean>>;
+    container: z.ZodMiniDefault<z.ZodMiniBoolean<boolean>>;
+    described: z.ZodMiniDefault<z.ZodMiniBoolean<boolean>>;
+}, z.core.$strict>;
+/** The parsed spec of one node kind, with defaults filled in. */
+export type NodeKindSpec = z.infer<typeof NodeKindSpecSchema>;
+/** What the registry states about one top-level section. */
+export declare const SectionSpecSchema: z.ZodMiniObject<{
+    label: z.ZodMiniString<string>;
+    description: z.ZodMiniString<string>;
+}, z.core.$strict>;
+/** The parsed spec of one section. */
+export type SectionSpec = z.infer<typeof SectionSpecSchema>;
+/** What the registry states about a family of relation kinds that the graph draws in one color. */
+export declare const RelationFamilySpecSchema: z.ZodMiniObject<{
+    label: z.ZodMiniString<string>;
+    description: z.ZodMiniString<string>;
+    colorToken: z.ZodMiniString<string>;
+}, z.core.$strict>;
+/** The parsed spec of one relation family. */
+export type RelationFamilySpec = z.infer<typeof RelationFamilySpecSchema>;
+/** What the registry states about one relation kind: what it means, which way it points and how it is drawn. */
+export declare const RelationKindSpecSchema: z.ZodMiniObject<{
+    label: z.ZodMiniString<string>;
+    description: z.ZodMiniString<string>;
+    forward: z.ZodMiniString<string>;
+    backward: z.ZodMiniString<string>;
+    from: z.ZodMiniString<string>;
+    to: z.ZodMiniString<string>;
+    family: z.ZodMiniString<string>;
+    dashed: z.ZodMiniDefault<z.ZodMiniBoolean<boolean>>;
+}, z.core.$strict>;
+/** The parsed spec of one relation kind, with defaults filled in. */
+export type RelationKindSpec = z.infer<typeof RelationKindSpecSchema>;
+/** The top-level sections, in display order. */
+export declare const SECTION_REGISTRY: {
+    readonly skills: {
+        readonly label: 'Skills';
+        readonly description: 'Every `SKILL.md` and the files beside it.';
+    };
+    readonly docs: {
+        readonly label: 'Docs';
+        readonly description: 'Markdown, JSON, OpenAPI documents and JSON Schemas.';
+    };
+    readonly code: {
+        readonly label: 'Code';
+        readonly description: 'Source files with their classes and functions.';
+    };
+    readonly database: {
+        readonly label: 'Database';
+        readonly description: 'SQL files, as schemas with their tables and as query catalogs.';
+    };
+    readonly tasks: {
+        readonly label: 'Tasks';
+        readonly description: 'Plans, their phases and their tasks, as task-manager keeps them.';
+    };
+};
+/** Every node kind, in the order the site lists kinds. */
+export declare const NODE_KIND_REGISTRY: {
+    readonly section: {
+        readonly group: 'section';
+        readonly label: 'section';
+        readonly description: 'A top-level group of the site.';
+    };
+    readonly folder: {
+        readonly group: 'folder';
+        readonly label: 'folder';
+        readonly description: 'A directory of the repository.';
+    };
+    readonly skill: {
+        readonly group: 'file';
+        readonly label: 'skill';
+        readonly description: 'A `SKILL.md`. The other files of its directory belong to it.';
+    };
+    readonly reference: {
+        readonly group: 'file';
+        readonly label: 'reference';
+        readonly description: 'A markdown file of a skill.';
+    };
+    readonly agent: {
+        readonly group: 'file';
+        readonly label: 'agent';
+        readonly description: 'A file in the `agents/` directory of a skill.';
+    };
+    readonly hook: {
+        readonly group: 'file';
+        readonly label: 'hook';
+        readonly description: 'A file in the `hooks/` directory of a skill.';
+    };
+    readonly schema: {
+        readonly group: 'file';
+        readonly label: 'schema';
+        readonly description: 'A JSON Schema, or a schema file of a skill.';
+    };
+    readonly asset: {
+        readonly group: 'file';
+        readonly label: 'file';
+        readonly description: 'Any other file of a skill.';
+    };
+    readonly document: {
+        readonly group: 'file';
+        readonly label: 'document';
+        readonly description: 'A markdown file.';
+    };
+    readonly json: {
+        readonly group: 'file';
+        readonly label: 'JSON';
+        readonly description: 'A JSON file.';
+    };
+    readonly glossary: {
+        readonly group: 'file';
+        readonly label: 'glossary';
+        readonly description: 'A `glossary.md`. Its terms are its entries.';
+    };
+    readonly decisions: {
+        readonly group: 'file';
+        readonly label: 'decisions';
+        readonly description: 'A `decisions.md`. Its decisions are its entries.';
+    };
+    readonly api: {
+        readonly group: 'file';
+        readonly label: 'API';
+        readonly description: 'An OpenAPI document. Its operations and definitions are its entries.';
+    };
+    readonly database: {
+        readonly group: 'file';
+        readonly label: 'database';
+        readonly description: 'A `.sql` file that creates tables. Its tables are its entries.';
+    };
+    readonly catalog: {
+        readonly group: 'file';
+        readonly label: 'catalog';
+        readonly description: 'A directory of `.sql` files that create no table. Its queries are its entries.';
+    };
+    readonly plan: {
+        readonly group: 'file';
+        readonly label: 'plan';
+        readonly description: 'A plan of the task tree. Its phases are its children.';
+    };
+    readonly phase: {
+        readonly group: 'file';
+        readonly label: 'phase';
+        readonly description: 'A phase of a plan. Its tasks are its entries.';
+    };
+    readonly source: {
+        readonly group: 'source';
+        readonly label: 'code';
+        readonly description: 'A source file. Its classes and functions are its entries.';
+    };
+    readonly namespace: {
+        readonly group: 'symbol';
+        readonly label: 'namespace';
+        readonly description: 'A namespace or a module.';
+        readonly letter: 'N';
+        readonly container: true;
+    };
+    readonly class: {
+        readonly group: 'symbol';
+        readonly label: 'class';
+        readonly description: 'A class.';
+        readonly letter: 'C';
+        readonly typeLike: true;
+        readonly container: true;
+    };
+    readonly interface: {
+        readonly group: 'symbol';
+        readonly label: 'interface';
+        readonly description: 'An interface or a protocol.';
+        readonly letter: 'I';
+        readonly typeLike: true;
+        readonly container: true;
+    };
+    readonly struct: {
+        readonly group: 'symbol';
+        readonly label: 'struct';
+        readonly description: 'A struct or a record.';
+        readonly letter: 'S';
+        readonly typeLike: true;
+        readonly container: true;
+    };
+    readonly enum: {
+        readonly group: 'symbol';
+        readonly label: 'enum';
+        readonly description: 'An enumeration.';
+        readonly letter: 'E';
+        readonly typeLike: true;
+        readonly container: true;
+    };
+    readonly trait: {
+        readonly group: 'symbol';
+        readonly label: 'trait';
+        readonly description: 'A trait or a mixin.';
+        readonly letter: 'T';
+        readonly typeLike: true;
+        readonly container: true;
+    };
+    readonly type: {
+        readonly group: 'symbol';
+        readonly label: 'type';
+        readonly description: 'A type alias.';
+        readonly letter: 'T';
+        readonly typeLike: true;
+        readonly container: true;
+    };
+    readonly function: {
+        readonly group: 'symbol';
+        readonly label: 'function';
+        readonly description: 'A function.';
+        readonly letter: 'F';
+    };
+    readonly method: {
+        readonly group: 'symbol';
+        readonly label: 'method';
+        readonly description: 'A method of a type.';
+        readonly letter: 'M';
+    };
+    readonly term: {
+        readonly group: 'entry';
+        readonly label: 'term';
+        readonly description: 'A word of the project and what it means.';
+        readonly prose: true;
+    };
+    readonly decision: {
+        readonly group: 'entry';
+        readonly label: 'decision';
+        readonly description: 'A choice that is costly to undo, with its reason.';
+        readonly prose: true;
+    };
+    readonly operation: {
+        readonly group: 'entry';
+        readonly label: 'operation';
+        readonly description: 'A method on a path of an API.';
+        readonly described: true;
+    };
+    readonly definition: {
+        readonly group: 'entry';
+        readonly label: 'definition';
+        readonly description: 'A named JSON Schema.';
+        readonly described: true;
+    };
+    readonly table: {
+        readonly group: 'entry';
+        readonly label: 'table';
+        readonly description: 'A table of a SQL schema.';
+        readonly described: true;
+    };
+    readonly query: {
+        readonly group: 'entry';
+        readonly label: 'query';
+        readonly description: 'An entry of a SQL query catalog.';
+        readonly described: true;
+    };
+    readonly task: {
+        readonly group: 'entry';
+        readonly label: 'task';
+        readonly description: 'One unit of work of a phase, with its status.';
+        readonly prose: true;
+    };
+    readonly parameter: {
+        readonly group: 'member';
+        readonly label: 'parameter';
+        readonly description: 'A parameter of a function, an operation or a query.';
+    };
+    readonly field: {
+        readonly group: 'member';
+        readonly label: 'field';
+        readonly description: 'A field of a type, a property, a column or a result column.';
+    };
+};
+/** The relation families, in legend order. */
+export declare const RELATION_FAMILY_REGISTRY: {
+    readonly typing: {
+        readonly label: 'typing';
+        readonly description: 'What a declaration is made of.';
+        readonly colorToken: '--edge-typing';
+    };
+    readonly result: {
+        readonly label: 'result';
+        readonly description: 'What a call gives back.';
+        readonly colorToken: '--edge-result';
+    };
+    readonly prose: {
+        readonly label: 'prose';
+        readonly description: 'What a text points at.';
+        readonly colorToken: '--edge-prose';
+    };
+    readonly term: {
+        readonly label: 'term';
+        readonly description: 'A text that uses a glossary term.';
+        readonly colorToken: '--edge-term';
+    };
+    readonly key: {
+        readonly label: 'key';
+        readonly description: 'A foreign key between two tables.';
+        readonly colorToken: '--edge-key';
+    };
+    readonly query: {
+        readonly label: 'query';
+        readonly description: 'A table a query reads or writes.';
+        readonly colorToken: '--edge-query';
+    };
+    readonly task: {
+        readonly label: 'task';
+        readonly description: 'What a task names, and what it waits for.';
+        readonly colorToken: '--edge-task';
+    };
+};
+/** Every relation kind other than `parent`, in the order the site lists them. */
+export declare const RELATION_KIND_REGISTRY: {
+    readonly type: {
+        readonly label: 'type';
+        readonly description: 'A parameter or field has that type, or the request body of an operation has that schema.';
+        readonly forward: 'has type';
+        readonly backward: 'is the type of';
+        readonly from: 'parameter, field, property or operation';
+        readonly to: 'type or definition';
+        readonly family: 'typing';
+    };
+    readonly returns: {
+        readonly label: 'returns';
+        readonly description: 'A function returns that type, or an operation answers with that schema.';
+        readonly forward: 'returns';
+        readonly backward: 'is returned by';
+        readonly from: 'function, method or operation';
+        readonly to: 'type or definition';
+        readonly family: 'result';
+    };
+    readonly throws: {
+        readonly label: 'throws';
+        readonly description: 'A function throws that type, or an operation answers an error with that schema.';
+        readonly forward: 'throws';
+        readonly backward: 'is thrown by';
+        readonly from: 'function, method or operation';
+        readonly to: 'type or definition';
+        readonly family: 'result';
+        readonly dashed: true;
+    };
+    readonly extends: {
+        readonly label: 'extends';
+        readonly description: 'A type extends, implements or is composed of that type.';
+        readonly forward: 'extends';
+        readonly backward: 'is extended by';
+        readonly from: 'type or definition';
+        readonly to: 'type or definition';
+        readonly family: 'typing';
+        readonly dashed: true;
+    };
+    readonly mentions: {
+        readonly label: 'mentions';
+        readonly description: 'A page or a description links to that node.';
+        readonly forward: 'mentions';
+        readonly backward: 'is mentioned by';
+        readonly from: 'page or entry';
+        readonly to: 'any node';
+        readonly family: 'prose';
+    };
+    readonly uses: {
+        readonly label: 'uses';
+        readonly description: 'A page, a description or a decision uses that glossary term.';
+        readonly forward: 'uses';
+        readonly backward: 'is used by';
+        readonly from: 'page, entry, parameter or field';
+        readonly to: 'term';
+        readonly family: 'term';
+    };
+    readonly affects: {
+        readonly label: 'affects';
+        readonly description: 'A decision is about that node.';
+        readonly forward: 'affects';
+        readonly backward: 'is affected by';
+        readonly from: 'decision';
+        readonly to: 'any node';
+        readonly family: 'prose';
+        readonly dashed: true;
+    };
+    readonly references: {
+        readonly label: 'references';
+        readonly description: 'A table has a foreign key to that table.';
+        readonly forward: 'references';
+        readonly backward: 'is referenced by';
+        readonly from: 'table';
+        readonly to: 'table';
+        readonly family: 'key';
+    };
+    readonly reads: {
+        readonly label: 'reads';
+        readonly description: 'A query selects from that table.';
+        readonly forward: 'reads';
+        readonly backward: 'is read by';
+        readonly from: 'query';
+        readonly to: 'table';
+        readonly family: 'query';
+    };
+    readonly writes: {
+        readonly label: 'writes';
+        readonly description: 'A statement inserts into, updates or deletes from that table.';
+        readonly forward: 'writes';
+        readonly backward: 'is written by';
+        readonly from: 'query';
+        readonly to: 'table';
+        readonly family: 'query';
+        readonly dashed: true;
+    };
+    readonly names: {
+        readonly label: 'names';
+        readonly description: 'A plan, a phase or a task links to that node or names it in inline code.';
+        readonly forward: 'names';
+        readonly backward: 'is named by';
+        readonly from: 'plan, phase or task';
+        readonly to: 'any node';
+        readonly family: 'task';
+    };
+    readonly depends: {
+        readonly label: 'depends';
+        readonly description: 'A plan, a phase or a task waits for that one to be completed.';
+        readonly forward: 'depends on';
+        readonly backward: 'is depended on by';
+        readonly from: 'plan, phase or task';
+        readonly to: 'plan, phase or task';
+        readonly family: 'task';
+        readonly dashed: true;
+    };
+};
+/** Slug of a top-level section, such as `code`. */
+export type Section = keyof typeof SECTION_REGISTRY;
+/** Kind of a node, such as `class` or `table`. */
+export type NodeKind = keyof typeof NODE_KIND_REGISTRY;
+/** Name of a relation family, such as `typing`. */
+export type RelationFamily = keyof typeof RELATION_FAMILY_REGISTRY;
+/** Kind of an edge: any relation kind other than `parent`. */
+export type EdgeKind = keyof typeof RELATION_KIND_REGISTRY;
+/** The node kinds whose group is one of `G`. */
+export type KindsIn<G extends NodeGroup> = {
+    [K in NodeKind]: (typeof NODE_KIND_REGISTRY)[K]['group'] extends G ? K : never;
+}[NodeKind];
+/** Every node kind with its parsed spec. */
+export declare const NODE_KINDS: Readonly<Record<NodeKind, NodeKindSpec>>;
+/** Every section with its parsed spec. */
+export declare const SECTION_SPECS: Readonly<Record<Section, SectionSpec>>;
+/** Every relation family with its parsed spec. */
+export declare const RELATION_FAMILIES: Readonly<Record<RelationFamily, RelationFamilySpec>>;
+/** Every relation kind with its parsed spec. */
+export declare const RELATION_KINDS: Readonly<Record<EdgeKind, RelationKindSpec & {
+    family: RelationFamily;
+}>>;
+/** The sections, in display order. */
+export declare const SECTIONS: readonly Section[];
+/** Every node kind, in registry order. */
+export declare const ALL_NODE_KINDS: readonly NodeKind[];
+/** Every relation kind, in registry order. */
+export declare const EDGE_KINDS: readonly EdgeKind[];
+/** Every relation family, in legend order. */
+export declare const RELATION_FAMILY_NAMES: readonly RelationFamily[];
+/** Lists the node kinds whose group is one of `groups`, in registry order. */
+export declare function kindsIn<G extends NodeGroup>(...groups: readonly G[]): readonly KindsIn<G>[];
+/** Lists the node kinds for which a flag of the registry is set. */
+export declare function kindsWith(flag: 'typeLike' | 'container' | 'described'): ReadonlySet<NodeKind>;

package/dist/query/graph.d.ts

@@ -0,0 +1,66 @@
+import { type BundleMeta, type DocsBundle, type Edge, type GraphNode, type NodeKind, type NodeRef, type Route, type Section, type SemanticIndex } from '../model';
+/** Tells whether a kind is a row of its entry (`parameter` or `field`) rather than a page or entry of its own. */
+export declare function isDeclarationKind(kind: NodeKind): kind is 'parameter' | 'field';
+/**
+ * The bundle as a graph the app can walk: children, routes and edges in both
+ * directions. Built once at startup.
+ *
+ * Holds the bundle's nodes and meta, the semantic index, and lookup tables
+ * built from them: child lists, the route of every node, pages by path,
+ * entries by `path#hash`, and edges by source and by target. `web/main.tsx`
+ * creates it from the embedded bundle and `api/source.ts` from a loaded one.
+ * The web app, `retrieval/` and the search functions in `query/` read it.
+ */
+export declare class Graph {
+    readonly meta: BundleMeta;
+    /** The embedding model and node vectors for search by meaning, when the page has them. */
+    readonly semantic: SemanticIndex | undefined;
+    private readonly nodes;
+    private readonly childRefs;
+    private readonly routes;
+    /** Route path to the page it shows. */
+    private readonly pages;
+    /** `path#hash` to the entry it names: a symbol, a term or a decision. */
+    private readonly anchors;
+    private readonly outgoing;
+    private readonly incoming;
+    /**
+     * The sections of the bundle, in display order. A bundle that an older
+     * version wrote has no `database` section, so a walk over every section
+     * goes through this list.
+     */
+    readonly sections: readonly {
+        readonly slug: Section;
+        readonly node: NodeRef;
+    }[];
+    /** Indexes the nodes and edges of a bundle. */
+    constructor(bundle: DocsBundle);
+    /** Returns the node at `ref`, and throws when there is none. */
+    node(ref: NodeRef): GraphNode;
+    /** Returns the children of a node in display order. */
+    children(ref: NodeRef): readonly NodeRef[];
+    /** From the section down to the parent of `ref`. */
+    ancestors(ref: NodeRef): NodeRef[];
+    /** Returns the route of the page that shows a node, and throws when there is no node at `ref`. */
+    route(ref: NodeRef): Route;
+    /** The node a location shows: the entry `hash` names on the page at `path`, else that page. */
+    at(path: string, hash?: string): NodeRef | undefined;
+    /** Returns the root node of a section, and throws when the bundle lacks it. */
+    section(slug: Section): NodeRef;
+    /** The section a node is in. */
+    sectionOf(ref: NodeRef): NodeRef;
+    /** Every node below `ref`, depth first, in display order. */
+    descendants(ref: NodeRef): Generator<NodeRef>;
+    /** Number of nodes below `ref` whose kind is one of `kinds`. */
+    count(ref: NodeRef, kinds: ReadonlySet<NodeKind>): number;
+    /** Returns the edges that start at a node. */
+    edgesFrom(ref: NodeRef): readonly Edge[];
+    /** Returns the edges that end at a node. */
+    edgesTo(ref: NodeRef): readonly Edge[];
+    /**
+     * Name of a node as other places refer to it: `Class.method` for a symbol,
+     * `Class.method(parameter)` for a parameter, `table.column` for a column,
+     * `query(:placeholder)` for a placeholder of a query, the file path for a page.
+     */
+    qualifiedName(ref: NodeRef): string;
+}

package/dist/query/index.d.ts

@@ -0,0 +1,4 @@
+export { Graph, isDeclarationKind } from './graph';
+export { buildSearchIndex, type SearchEntry, type SearchMatch, search } from './name-search';
+export { embeddingModelName, type MeaningOptions, searchByMeaning, similarNodes } from './semantic';
+export { codeText, firstParagraph, plainText } from './text';

package/dist/query/name-search.d.ts

@@ -0,0 +1,47 @@
+import { type NodeKind, type NodeRef } from '../model';
+import type { Graph } from './graph';
+/** What search by words knows about one page or entry. */
+export interface SearchEntry {
+    readonly node: NodeRef;
+    readonly kind: NodeKind;
+    /** Name of the section the node is in. Results are grouped by it. */
+    readonly group: string;
+    readonly title: string;
+    readonly detail: string;
+    /** Lowercase text that names the node: its title, the words of its name, the words it replaces. */
+    readonly haystack: string;
+    /** Lowercase words of `detail`, each with a space in front of it. */
+    readonly place: string;
+    /**
+     * Lowercase words that describe the node: its description, its definition,
+     * the page. Every word has a space in front of it, so a search can tell the
+     * start of a word from its middle.
+     */
+    readonly text: string;
+}
+/** One result of a search by words. */
+export interface SearchMatch {
+    readonly entry: SearchEntry;
+    /** `name`: every word of the query is in what names the node. `text`: at least one is only in what describes it. */
+    readonly found: 'name' | 'text';
+}
+/**
+ * Builds the index for search by words: one entry per file, symbol, glossary
+ * term, decision, API operation, schema definition, table and query. Folders,
+ * parameters and fields are not searched.
+ *
+ * @returns The entries in display order.
+ */
+export declare function buildSearchIndex(graph: Graph): SearchEntry[];
+/**
+ * Finds the entries that contain every word of a query. Entries that are
+ * named by the words come first: an exact title, then a title that starts
+ * with the query, then other names. Entries in a file whose path holds a
+ * word follow, then entries that mention a word in their description. A word
+ * of the query may be the start of a word of the description.
+ *
+ * @param index - The index from `buildSearchIndex`.
+ * @param query - What the reader typed.
+ * @returns The matches, best first.
+ */
+export declare function search(index: readonly SearchEntry[], query: string, limit: number): SearchMatch[];

package/dist/query/semantic.d.ts

@@ -0,0 +1,30 @@
+import { type SemanticHit } from '../embeddings';
+import { type NodeRef } from '../model';
+import type { Graph } from './graph';
+/** Narrows a search by meaning. */
+export interface MeaningOptions {
+    /** Most hits to return. Default: the number the search dialog shows. */
+    readonly limit?: number;
+    /** Says which nodes count. Default: every node. */
+    readonly accepts?: (node: NodeRef) => boolean;
+}
+/**
+ * Finds nodes by the meaning of a query, such as the term `Sailing` for the query `ship`.
+ *
+ * @param query - What the reader typed.
+ * @param exclude - Nodes that are listed already.
+ * @returns The closest nodes, best first. Empty for a graph without embeddings.
+ */
+export declare function searchByMeaning(graph: Graph, query: string, exclude: ReadonlySet<NodeRef>, options?: MeaningOptions): SemanticHit[];
+/**
+ * Finds the nodes whose meaning is closest to that of a node.
+ *
+ * @returns The closest nodes, best first. Empty for a graph without embeddings.
+ */
+export declare function similarNodes(graph: Graph, node: NodeRef): SemanticHit[];
+/**
+ * Names the embedding model of a graph.
+ *
+ * @returns The name, or `null` for a graph without embeddings.
+ */
+export declare function embeddingModelName(graph: Graph): string | null;

package/dist/query/text.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Reduces scanner HTML to the text a reader sees, on one line.
+ *
+ * @param html - HTML of a description or a page.
+ * @returns The text without tags, with whitespace collapsed. Inline tags leave no gap, so `<code>a</code>.` reads `a.`
+ */
+export declare function plainText(html: string): string;
+/**
+ * Reads source code back out of a highlighted `<pre>` block.
+ *
+ * @param html - HTML of a signature, an example or a file shown as text.
+ * @returns The code with its line breaks, without the highlighting.
+ */
+export declare function codeText(html: string): string;
+/**
+ * Takes the first paragraph of a description as its summary.
+ *
+ * @param html - HTML of a description or a page.
+ * @param maxLength - Longest summary. A longer paragraph is cut at a word and ends with `...`.
+ * @returns The paragraph as plain text, or `''` when the HTML has no paragraph.
+ */
+export declare function firstParagraph(html: string, maxLength?: number): string;