@sema-agent/core/dist/core/namespaced-rule-name.js

Stateless, task-oriented AI agent core

import { splitNamespacedName } from "./tool-name-aliases.js";
export function wildcardMatch(pattern, value) {
    let p = 0;
    let v = 0;
    let star = -1;
    let mark = 0;
    while (v < value.length) {
        if (p < pattern.length && pattern[p] === value[v] && pattern[p] !== "*") {
            p++;
            v++;
        }
        else if (p < pattern.length && pattern[p] === "*") {
            star = p++;
            mark = v;
        }
        else if (star >= 0) {
            p = star + 1;
            v = ++mark;
        }
        else {
            return false;
        }
    }
    while (p < pattern.length && pattern[p] === "*")
        p++;
    return p === pattern.length;
}
function parseNamespacedRuleName(name) {
    const split = splitNamespacedName(name);
    if (split === undefined || split.peer === "")
        return undefined;
    return split.tool !== undefined ? { protocol: split.ns.id, peer: split.peer, tool: split.tool } : { protocol: split.ns.id, peer: split.peer };
}
export function namespacedRuleNameCovers(ruleName, toolName) {
    const rule = parseNamespacedRuleName(ruleName);
    if (rule === undefined)
        return false;
    const target = parseNamespacedRuleName(toolName);
    if (target === undefined)
        return false;
    if (rule.protocol !== target.protocol)
        return false;
    if (rule.peer !== target.peer)
        return false;
    if (rule.tool === undefined || rule.tool === "*")
        return true;
    return target.tool !== undefined && rule.tool.includes("*") && wildcardMatch(rule.tool, target.tool);
}
export function isNamespacedCoveringRuleName(name) {
    const parsed = parseNamespacedRuleName(name);
    return parsed !== undefined && (parsed.tool === undefined || parsed.tool.includes("*"));
}