@agentxm/registry-protocol 0.28.11 → 0.28.13

package/dist/src/unstable/knowledge/knowledge-search.js

@@ -1,147 +0,0 @@
-export const KNOWLEDGE_SEARCH_TOKENIZER_PROFILE = {
-    id: "axm-knowledge-lexical-v1",
-    unicodeNormalization: "NFKC",
-    caseNormalization: "unicode-case-fold",
-    termBoundary: "unicode-whitespace-punctuation-camel-code",
-    stemming: false,
-};
-const normalizeTokenSource = (value) => value
-    .normalize("NFKC")
-    .replace(/([\p{Ll}\p{N}])(\p{Lu})/gu, "$1 $2")
-    .replace(/(\p{Lu})(\p{Lu}\p{Ll})/gu, "$1 $2")
-    .replace(/(\p{L})(\p{N})/gu, "$1 $2")
-    .replace(/(\p{N})(\p{L})/gu, "$1 $2")
-    // ECMAScript does not expose Unicode's CaseFolding.txt operation directly.
-    // Upper-then-lower handles multi-character folds such as ß -> ss while
-    // remaining deterministic and locale-independent.
-    .toUpperCase()
-    .toLowerCase();
-export const tokenizeKnowledgeSearchText = (value) => normalizeTokenSource(value).match(/[\p{L}\p{M}\p{N}]+/gu) ?? [];
-const normalizeLiteral = (value) => value.normalize("NFC").toLowerCase();
-const parseQuotedValue = (input, quoteIndex) => {
-    let value = "";
-    let escaped = false;
-    for (let index = quoteIndex + 1; index < input.length; index += 1) {
-        const character = input[index];
-        if (character === undefined)
-            break;
-        if (escaped) {
-            value += character;
-            escaped = false;
-            continue;
-        }
-        if (character === "\\") {
-            escaped = true;
-            continue;
-        }
-        if (character === '"') {
-            return { ok: true, value, nextIndex: index + 1 };
-        }
-        value += character;
-    }
-    return { ok: false };
-};
-const addOrdinaryTerms = (clauses, value) => {
-    for (const token of tokenizeKnowledgeSearchText(value)) {
-        clauses.push({ kind: "term", token });
-    }
-};
-const startsWithLiteralOperator = (input, index) => input.slice(index, index + "literal:".length).toLowerCase() === "literal:";
-export const parseKnowledgeSearchQuery = (input) => {
-    const clauses = [];
-    let index = 0;
-    while (index < input.length) {
-        if (/\s/u.test(input[index] ?? "")) {
-            index += 1;
-            continue;
-        }
-        if (startsWithLiteralOperator(input, index)) {
-            index += "literal:".length;
-            if (input[index] === '"') {
-                const quoted = parseQuotedValue(input, index);
-                if (!quoted.ok) {
-                    return { ok: false, detail: "Explicit literals must end with a closing quote." };
-                }
-                if (quoted.value.trim().length === 0) {
-                    return { ok: false, detail: "Explicit literals cannot be empty." };
-                }
-                clauses.push({ kind: "literal", value: normalizeLiteral(quoted.value) });
-                index = quoted.nextIndex;
-                continue;
-            }
-            const end = input.slice(index).search(/\s/u);
-            const nextIndex = end === -1 ? input.length : index + end;
-            const value = input.slice(index, nextIndex);
-            if (value.length === 0) {
-                return { ok: false, detail: "Explicit literals cannot be empty." };
-            }
-            clauses.push({ kind: "literal", value: normalizeLiteral(value) });
-            index = nextIndex;
-            continue;
-        }
-        if (input[index] === '"') {
-            const quoted = parseQuotedValue(input, index);
-            if (!quoted.ok) {
-                return { ok: false, detail: "Quoted phrases must end with a closing quote." };
-            }
-            if (quoted.value.length === 0) {
-                return { ok: false, detail: "Quoted phrases cannot be empty." };
-            }
-            const tokens = tokenizeKnowledgeSearchText(quoted.value);
-            if (tokens.length === 0) {
-                return {
-                    ok: false,
-                    detail: "Quoted phrases must contain at least one searchable token.",
-                };
-            }
-            clauses.push({ kind: "phrase", tokens });
-            index = quoted.nextIndex;
-            continue;
-        }
-        let end = index;
-        while (end < input.length && !/\s/u.test(input[end] ?? "") && input[end] !== '"') {
-            end += 1;
-        }
-        addOrdinaryTerms(clauses, input.slice(index, end));
-        index = end;
-    }
-    return clauses.length === 0
-        ? { ok: false, detail: "Search query must contain at least one term, phrase, or literal." }
-        : { ok: true, query: { clauses } };
-};
-const containsPhrase = (fieldTokens, phraseTokens) => {
-    if (phraseTokens.length > fieldTokens.length)
-        return false;
-    const finalStart = fieldTokens.length - phraseTokens.length;
-    for (let start = 0; start <= finalStart; start += 1) {
-        if (phraseTokens.every((token, offset) => fieldTokens[start + offset] === token))
-            return true;
-    }
-    return false;
-};
-const searchableFields = (concept) => [
-    concept.id,
-    concept.title,
-    ...(concept.description === undefined ? [] : [concept.description]),
-    ...(concept.tags ?? []),
-    ...(concept.type === undefined ? [] : [concept.type]),
-    concept.body,
-];
-export const matchesKnowledgeSearchQuery = (concept, query) => {
-    const fields = searchableFields(concept);
-    const tokenFields = fields.map(tokenizeKnowledgeSearchText);
-    const literalFields = fields.map(normalizeLiteral);
-    return query.clauses.every((clause) => {
-        switch (clause.kind) {
-            case "term":
-                return tokenFields.some((tokens) => tokens.includes(clause.token));
-            case "phrase":
-                return tokenFields.some((tokens) => containsPhrase(tokens, clause.tokens));
-            case "literal":
-                return literalFields.some((field) => field.includes(clause.value));
-            default:
-                return clause;
-        }
-    });
-};
-//# sourceMappingURL=knowledge-search.js.map

package/dist/src/unstable/knowledge/okf.d.ts

@@ -1,86 +0,0 @@
-/** Open Knowledge Format discovery and AgentXM-profile validation (v0.2). */
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Path from "effect/Path";
-import { FrontmatterParseFailure } from "../content/frontmatter.js";
-import { type KnowledgeSearchQuery } from "./knowledge-search.js";
-/** OKF dialect versions this inspector understands. */
-export type OkfVersion = "0.2";
-/** Actor that produced or confirmed a concept, per the OKF actor convention. */
-export interface KnowledgeActorRecord {
-    readonly by: string;
-    readonly at?: string;
-}
-/**
- * Trust tier derived from `verified`, per OKF 0.2. A concept is
- * `human-reviewed` when any verifier is a `human:<id>` actor,
- * `machine-confirmed` when verified only by non-human actors, and
- * `unverified` when `verified` is absent.
- */
-export type KnowledgeTrustTier = "unverified" | "machine-confirmed" | "human-reviewed";
-export type KnowledgeDocumentKind = "concept" | "index" | "log";
-/** An authored Markdown link and the bundle-local concept it resolves to, when any. */
-export interface KnowledgeAuthoredLink {
-    readonly target: string;
-    readonly line: number;
-    readonly resolvedConceptId?: string;
-}
-export interface KnowledgeConcept {
-    readonly id: string;
-    readonly kind: KnowledgeDocumentKind;
-    readonly title: string;
-    /** The authored level-one heading, absent when `title` fell back to the concept ID. */
-    readonly authoredTitle?: string;
-    readonly frontmatter?: Readonly<Record<string, unknown>>;
-    readonly type?: string;
-    readonly description?: string;
-    readonly tags?: ReadonlyArray<string>;
-    readonly resource?: string;
-    readonly status?: string;
-    readonly staleAfter?: string;
-    readonly generated?: KnowledgeActorRecord;
-    readonly verified?: ReadonlyArray<KnowledgeActorRecord>;
-    readonly trust?: KnowledgeTrustTier;
-    readonly authoredLinks: ReadonlyArray<KnowledgeAuthoredLink>;
-    readonly relativePath: string;
-    readonly body: string;
-}
-export declare const KNOWLEDGE_DIAGNOSTIC_CODES: readonly ["bundle-too-large", "file-too-large", "invalid-tags", "missing-root-index", "missing-okf-version", "missing-title", "missing-description", "missing-manifest-description", "empty-bundle", "missing-tags", "symbolic-link", "too-many-files", "unsupported-okf-version", "missing-type", "invalid-frontmatter", "case-collision", "dangerous-uri", "detected-secret", "unsafe-path", "invalid-index", "invalid-log", "invalid-resource", "escaping-resource", "unresolved-resource", "broken-internal-link", "escaping-link", "unreachable-concept", "missing-index-entry", "stale-index-entry", "embedded-html", "duplicate-resource", "inconsistent-type", "large-concept", "large-index", "unreferenced-asset", "invalid-sources", "invalid-generated", "invalid-verified", "invalid-status", "invalid-stale-after", "invalid-attestation"];
-export type KnowledgeDiagnosticCode = (typeof KNOWLEDGE_DIAGNOSTIC_CODES)[number];
-export interface KnowledgeFrontmatterParseDetails {
-    readonly kind: "frontmatter-parse";
-    readonly reason: string;
-}
-export interface KnowledgeDiagnostic {
-    readonly code: KnowledgeDiagnosticCode;
-    readonly severity: "error" | "warning";
-    readonly relativePath: string;
-    readonly line?: number;
-    readonly column?: number;
-    readonly message: string;
-    readonly details?: KnowledgeFrontmatterParseDetails;
-}
-/** Convert a typed frontmatter failure into the stable Knowledge diagnostic contract. */
-export declare const frontmatterParseDiagnostic: (relativePath: string, failure: FrontmatterParseFailure) => KnowledgeDiagnostic;
-export interface KnowledgeInspection {
-    readonly concepts: ReadonlyArray<KnowledgeConcept>;
-    readonly diagnostics: ReadonlyArray<KnowledgeDiagnostic>;
-    /** Canonical dialect required at the bundle root. */
-    readonly okfVersion: OkfVersion;
-}
-export interface KnowledgeBundleEntry {
-    readonly relativePath: string;
-    readonly type: FileSystem.File.Type;
-    readonly size: bigint;
-}
-/** Collect a bundle's normalized entry inventory without following symbolic links. */
-export declare const collectKnowledgeBundleEntries: (sourceRoot: string) => Effect.Effect<ReadonlyArray<KnowledgeBundleEntry>, unknown, FileSystem.FileSystem | Path.Path>;
-/**
- * Inspect a canonical OKF 0.2 bundle. The root index requirement is an explicit
- * AgentXM profile constraint; upstream OKF permits a root without it.
- */
-export declare const inspectKnowledgeEntries: <E>(entries: ReadonlyArray<KnowledgeBundleEntry>, readMarkdown: (relativePath: string) => Effect.Effect<string, E>) => Effect.Effect<KnowledgeInspection, E>;
-export declare const inspectKnowledgeBundle: (sourceRoot: string) => Effect.Effect<KnowledgeInspection, unknown, FileSystem.FileSystem | Path.Path>;
-export declare const searchKnowledgeConcepts: (concepts: ReadonlyArray<KnowledgeConcept>, query: KnowledgeSearchQuery) => ReadonlyArray<KnowledgeConcept>;
-export declare const openKnowledgeConcept: (concepts: ReadonlyArray<KnowledgeConcept>, id: string) => KnowledgeConcept | undefined;
-//# sourceMappingURL=okf.d.ts.map