import {

createMemoryWikiImportRunStateStore,

readMemoryWikiImportRunRecord,

resolveMemoryWikiImportRunRecordPath,

} from "./src/import-runs-state.js";

import {

createMemoryWikiSourceSyncStateStore,

return dir;

}

function resolveLegacyImportRunRecordPath(vaultRoot: string, runId: string): string {

return path.join(vaultRoot, ".openclaw-wiki", "import-runs", `${runId}.json`);

}

function migrationParams(params: { stateDir: string; vaultRoot: string }) {

const env = { ...process.env, HOME: params.stateDir, OPENCLAW_STATE_DIR: params.stateDir };

return {

it("detects and migrates legacy import-run records into plugin state", async () => {

const stateDir = await makeTempDir();

const vaultRoot = path.join(stateDir, "vault");

const legacyPath = resolveMemoryWikiImportRunRecordPath(vaultRoot, "chatgpt-alpha");

const legacyPath = resolveLegacyImportRunRecordPath(vaultRoot, "chatgpt-alpha");

const snapshotPath = path.join(

vaultRoot,

".openclaw-wiki",

runWikiStatus,

} from "./cli.js";

import type { MemoryWikiPluginConfig } from "./config.js";

import { resolveMemoryWikiImportRunRecordPath } from "./import-runs-state.js";

import { parseWikiMarkdown, renderWikiMarkdown } from "./markdown.js";

import type { MemoryWikiDoctorReport, MemoryWikiStatus } from "./status.js";

import { createMemoryWikiTestHarness } from "./test-helpers.js";

let caseIndex = 0;

let stdoutWriteMock: ReturnType<typeof vi.fn>;

function resolveLegacyImportRunRecordPath(vaultRoot: string, runId: string): string {

return path.join(vaultRoot, ".openclaw-wiki", "import-runs", `${runId}.json`);

}

describe("memory-wiki cli", () => {

beforeAll(async () => {

suiteRoot = await fs.mkdtemp(path.join(os.tmpdir(), "memory-wiki-cli-suite-"));

expect(applied.runId).toMatch(/^chatgpt-[a-f0-9]{12}$/u);

expect(applied.createdCount).toBe(1);

await expect(

fs.stat(resolveMemoryWikiImportRunRecordPath(rootDir, applied.runId ?? "")),

fs.stat(resolveLegacyImportRunRecordPath(rootDir, applied.runId ?? "")),

).rejects.toMatchObject({ code: "ENOENT" });

const sourceFiles = (await fs.readdir(path.join(rootDir, "sources"))).filter(

(entry) => entry !== "index.md",

return path.join(vaultRoot, ".openclaw-wiki", "import-runs");

}

export function resolveMemoryWikiImportRunRecordPath(vaultRoot: string, runId: string): string {

return path.join(resolveMemoryWikiImportRunsDir(vaultRoot), `${runId}.json`);

}

function resolveVaultRootKey(vaultRoot: string): string {

return createHash("sha256").update(path.resolve(vaultRoot), "utf8").digest("hex").slice(0, 32);

}

import path from "node:path";

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

import { resolveMemoryWikiConfig } from "./config.js";

import { buildWikiPromptSection, createWikiPromptSectionBuilder } from "./prompt-section.js";

import { createWikiPromptSectionBuilder } from "./prompt-section.js";

let suiteRoot = "";

}

});

describe("buildWikiPromptSection", () => {

const buildDefaultWikiPromptSection = createWikiPromptSectionBuilder(

resolveMemoryWikiConfig({

vault: { path: "" },

context: { includeCompiledDigestPrompt: false },

}),

);

describe("default wiki prompt section", () => {

it("prefers shared memory corpus guidance when memory tools are available", () => {

const lines = buildWikiPromptSection({

const lines = buildDefaultWikiPromptSection({

availableTools: new Set(["memory_search", "memory_get", "wiki_search", "wiki_get"]),

});

});

it("stays empty when no wiki or memory-adjacent tools are registered", () => {

expect(buildWikiPromptSection({ availableTools: new Set(["web_search"]) })).toStrictEqual([]);

expect(

buildDefaultWikiPromptSection({ availableTools: new Set(["web_search"]) }),

).toStrictEqual([]);

});

it("can append a compact compiled digest snapshot when enabled", async () => {

import fs from "node:fs";

import path from "node:path";

import type { MemoryPromptSectionBuilder } from "openclaw/plugin-sdk/memory-host-core";

import { resolveMemoryWikiConfig, type ResolvedMemoryWikiConfig } from "./config.js";

import type { ResolvedMemoryWikiConfig } from "./config.js";

const AGENT_DIGEST_PATH = ".openclaw-wiki/cache/agent-digest.json";

const DIGEST_MAX_PAGES = 4;

return [...toolGuidance, ...digestLines];

};

}

export const buildWikiPromptSection: MemoryPromptSectionBuilder = ({ availableTools }) =>

createWikiPromptSectionBuilder(

resolveMemoryWikiConfig({

vault: { path: "" },

context: { includeCompiledDigestPrompt: false },

}),

)({ availableTools });