import { withTempDir } from "../test-helpers/temp-dir.js";

import {

type ConfigDocBaselineEntry,

flattenConfigDocBaselineEntries,

renderConfigDocBaselineArtifacts,

writeConfigDocBaselineArtifacts,

} from "./doc-baseline.js";

function getSharedByPath() {

sharedByPathPromise ??= getSharedRendered().then(

({ baseline }) =>

new Map(flattenConfigDocBaselineEntries(baseline).map((entry) => [entry.path, entry])),

new Map(

[

...baseline.coreEntries,

...baseline.channelEntries,

...baseline.pluginEntries,

].map((entry) => [entry.path, entry]),

),

);

return sharedByPathPromise;

}

import {

collectConfigDocBaselineEntries,

dedupeConfigDocBaselineEntries,

normalizeConfigDocBaselineHelpPath,

} from "./doc-baseline.js";

describe("config doc baseline", () => {

it("normalizes array and record paths to wildcard form", () => {

expect(normalizeConfigDocBaselineHelpPath("agents.list[].skills")).toBe("agents.list.*.skills");

expect(normalizeConfigDocBaselineHelpPath("session.sendPolicy.rules[0].match.keyPrefix")).toBe(

"session.sendPolicy.rules.*.match.keyPrefix",

);

expect(normalizeConfigDocBaselineHelpPath(".env.*.")).toBe("env.*");

});

it("merges tuple item metadata instead of dropping earlier entries", () => {

const entries = dedupeConfigDocBaselineEntries(

collectConfigDocBaselineEntries(

return { coreEntries, channelEntries, pluginEntries };

}

export function flattenConfigDocBaselineEntries(

baseline: ConfigDocBaseline,

): ConfigDocBaselineEntry[] {

return [...baseline.coreEntries, ...baseline.channelEntries, ...baseline.pluginEntries];

}

async function buildConfigDocBaseline(): Promise<ConfigDocBaseline> {

if (cachedConfigDocBaselinePromise) {

return await cachedConfigDocBaselinePromise;

hashPath,

};

}

export function normalizeConfigDocBaselineHelpPath(pathValue: string): string {

return normalizeBaselinePath(pathValue);

}

// Node match tests cover node selection from names, ids, and address hints.

import { describe, expect, it } from "vitest";

import { normalizeNodeKey, resolveNodeIdFromCandidates, resolveNodeMatches } from "./node-match.js";

import { normalizeNodeKey, resolveNodeIdFromCandidates } from "./node-match.js";

describe("shared/node-match", () => {

it("normalizes node keys by lowercasing and collapsing separators", () => {

expect(normalizeNodeKey("###")).toBe("");

});

it("matches candidates by node id, remote ip, normalized name, and long prefix", () => {

const nodes = [

{ nodeId: "mac-abcdef", displayName: "Mac Studio", remoteIp: "100.0.0.1" },

{ nodeId: "pi-456789", displayName: "Raspberry Pi", remoteIp: "100.0.0.2" },

];

expect(resolveNodeMatches(nodes, "mac-abcdef")).toEqual([nodes[0]]);

expect(resolveNodeMatches(nodes, "100.0.0.2")).toEqual([nodes[1]]);

expect(resolveNodeMatches(nodes, "mac studio")).toEqual([nodes[0]]);

expect(resolveNodeMatches(nodes, " Mac---Studio!! ")).toEqual([nodes[0]]);

expect(resolveNodeMatches(nodes, "pi-456")).toEqual([nodes[1]]);

expect(resolveNodeMatches(nodes, "openclaw")).toStrictEqual([]);

expect(resolveNodeMatches(nodes, " ")).toStrictEqual([]);

});

it("resolves unique matches and prefers a unique connected node", () => {

expect(

resolveNodeIdFromCandidates(

.filter((entry): entry is ScoredNodeMatch => entry !== null);

}

/** Returns candidates matching a node id, remote ip, normalized display name, or long id prefix. */

export function resolveNodeMatches(

nodes: NodeMatchCandidate[],

query: string,

): NodeMatchCandidate[] {

return resolveScoredMatches(nodes, query).map((entry) => entry.node);

}

/** Resolves a single node id or throws an operator-readable unknown/ambiguous-node error. */

export function resolveNodeIdFromCandidates(nodes: NodeMatchCandidate[], query: string): string {

const q = query.trim();