mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-16 20:11:08 +00:00
* feat(vault): let Skills + CLI operate notes with the same approval as MCP Expose vault note list, read, write, and markdown import on the tool CLI so agents can save generated documents only after the user approves. Co-authored-by: Cursor <cursoragent@cursor.com> * fix(vault): keep explicit empty note fields in the CLI A supplied empty string was treated as an omitted flag, so note clears and empty markdown imports never reached the note service. Co-authored-by: Cursor <cursoragent@cursor.com> * fix(vault): allow an explicit empty note body on CLI create notes create --content "" was rejected as a missing flag, so it did not match vault_notes_create. Co-authored-by: Cursor <cursoragent@cursor.com> * fix(vault): stop echoing imported note bodies and recognize leading CLI flags A batch import resent every document over IPC, and a leading --json hid the notes command from artifact inference. Co-authored-by: Cursor <cursoragent@cursor.com> * fix(vault): make note CLI import safe and fail writes cleanly --------- Co-authored-by: Cursor <cursoragent@cursor.com> Co-authored-by: bincxz <16399091+binaricat@users.noreply.github.com>
648 lines
22 KiB
TypeScript
648 lines
22 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import test from "node:test";
|
|
import {
|
|
buildVaultNoteMarkdownExportFiles,
|
|
buildVaultNoteFromMarkdownImport,
|
|
calculateNoteStats,
|
|
deriveNoteImportTitle,
|
|
extractAllNoteTags,
|
|
extractNoteHeadings,
|
|
extractNoteSnippet,
|
|
filterAndSortVaultNotes,
|
|
formatMarkdownListSelection,
|
|
formatMarkdownQuoteSelection,
|
|
getVaultNotesForExportScope,
|
|
importMarkdownFilesToVaultNotes,
|
|
importMarkdownPayloadsToVaultNotes,
|
|
matchesVaultNoteSearch,
|
|
createVaultNoteSearchIndex,
|
|
normalizeNoteGroups,
|
|
normalizeVaultNotes,
|
|
remapExpandedNoteGroupPaths,
|
|
resolveMovedNoteGroupPath,
|
|
resolveRenderedMarkdownLinkHref,
|
|
sanitizeNoteExportFileNamePart,
|
|
sanitizeNoteTitle,
|
|
sanitizeVaultNote,
|
|
wrapMarkdownSyntax,
|
|
} from "./notes.ts";
|
|
|
|
test("sanitizeVaultNote supplies safe defaults", () => {
|
|
const note = sanitizeVaultNote({ title: " ", content: 123 as never });
|
|
assert.equal(note.title, "");
|
|
assert.equal(note.content, "");
|
|
assert.equal(typeof note.id, "string");
|
|
assert.equal(typeof note.createdAt, "number");
|
|
});
|
|
|
|
test("sanitizeNoteTitle preserves non-empty titles and allows empty titles", () => {
|
|
assert.equal(sanitizeNoteTitle(" My note "), "My note");
|
|
assert.equal(sanitizeNoteTitle(""), "");
|
|
assert.equal(sanitizeNoteTitle(" "), "");
|
|
assert.equal(sanitizeNoteTitle(undefined), "");
|
|
});
|
|
|
|
test("normalizeVaultNotes trims group and de-duplicates tags", () => {
|
|
const notes = normalizeVaultNotes([
|
|
{
|
|
id: "n1",
|
|
title: " Runbook ",
|
|
content: "body",
|
|
group: " Ops ",
|
|
tags: ["db", "db", " psql "],
|
|
createdAt: 1,
|
|
updatedAt: 2,
|
|
},
|
|
]);
|
|
|
|
assert.equal(notes[0].title, "Runbook");
|
|
assert.equal(notes[0].group, "Ops");
|
|
assert.deepEqual(notes[0].tags, ["db", "psql"]);
|
|
});
|
|
|
|
test("normalizeNoteGroups trims and de-duplicates groups", () => {
|
|
assert.deepEqual(normalizeNoteGroups([" Ops ", "Ops", "", 1]), ["Ops"]);
|
|
});
|
|
|
|
test("resolveMovedNoteGroupPath avoids merging with an existing target folder", () => {
|
|
assert.equal(
|
|
resolveMovedNoteGroupPath("Archive/DB", "Ops", [
|
|
"Ops",
|
|
"Ops/DB",
|
|
"Archive/DB",
|
|
"Archive/DB/Runbooks",
|
|
]),
|
|
"Ops/DB 2",
|
|
);
|
|
});
|
|
|
|
test("resolveMovedNoteGroupPath normalizes existing paths before detecting conflicts", () => {
|
|
assert.equal(
|
|
resolveMovedNoteGroupPath("Archive/DB", "Ops", [
|
|
"Ops",
|
|
"Ops / DB",
|
|
"Archive/DB",
|
|
]),
|
|
"Ops/DB 2",
|
|
);
|
|
});
|
|
|
|
test("resolveMovedNoteGroupPath rejects moving a folder into itself", () => {
|
|
assert.equal(
|
|
resolveMovedNoteGroupPath("Ops", "Ops/DB", ["Ops", "Ops/DB"]),
|
|
null,
|
|
);
|
|
});
|
|
|
|
test("remapExpandedNoteGroupPaths preserves expanded descendants after folder moves", () => {
|
|
assert.deepEqual(
|
|
[...remapExpandedNoteGroupPaths(
|
|
new Set(["Archive", "Archive/DB", "Archive/DB/Runbooks", "Ops"]),
|
|
"Archive/DB",
|
|
"Ops/DB 2",
|
|
)].sort(),
|
|
["Archive", "Ops", "Ops/DB 2", "Ops/DB 2/Runbooks"],
|
|
);
|
|
});
|
|
|
|
test("matchesVaultNoteSearch checks title, body, tags, group, and linked hosts", () => {
|
|
const note = sanitizeVaultNote({
|
|
id: "n1",
|
|
title: "Failover",
|
|
content: "Promote replica",
|
|
group: "Ops",
|
|
tags: ["postgres"],
|
|
linkedHostIds: ["h1"],
|
|
createdAt: 1,
|
|
updatedAt: 1,
|
|
});
|
|
const hosts = [{ id: "h1", label: "db-prod", hostname: "10.0.0.5" }] as never;
|
|
|
|
assert.equal(matchesVaultNoteSearch(note, "postgres", hosts), true);
|
|
assert.equal(matchesVaultNoteSearch(note, "db-prod", hosts), true);
|
|
assert.equal(matchesVaultNoteSearch(note, "missing", hosts), false);
|
|
});
|
|
|
|
test("sanitizeNoteExportFileNamePart removes unsafe path characters", () => {
|
|
assert.equal(sanitizeNoteExportFileNamePart(" a/b:c* ", "note"), "a-b-c-");
|
|
assert.equal(sanitizeNoteExportFileNamePart("a\u0001b", "note"), "a-b");
|
|
assert.equal(sanitizeNoteExportFileNamePart("..", "note"), "note");
|
|
assert.equal(sanitizeNoteExportFileNamePart("CON", "note"), "CON_");
|
|
assert.equal(sanitizeNoteExportFileNamePart("CON.txt", "note"), "CON_.txt");
|
|
assert.equal(sanitizeNoteExportFileNamePart("com1.backup.md", "note"), "com1_.backup.md");
|
|
assert.equal(sanitizeNoteExportFileNamePart("release.CON", "note"), "release.CON");
|
|
});
|
|
|
|
test("getVaultNotesForExportScope includes only selected folder descendants", () => {
|
|
const notes = [
|
|
sanitizeVaultNote({ id: "n1", title: "Root", content: "root", createdAt: 1, updatedAt: 1, order: 1000 }),
|
|
sanitizeVaultNote({ id: "n2", title: "Ops", content: "ops", group: "Ops", createdAt: 1, updatedAt: 1, order: 2000 }),
|
|
sanitizeVaultNote({ id: "n3", title: "DB", content: "db", group: "Ops/DB", createdAt: 1, updatedAt: 1, order: 3000 }),
|
|
sanitizeVaultNote({ id: "n4", title: "Other", content: "other", group: "Other", createdAt: 1, updatedAt: 1, order: 4000 }),
|
|
];
|
|
|
|
assert.deepEqual(
|
|
getVaultNotesForExportScope(notes, { type: "group", group: "Ops" }).map((item) => item.id),
|
|
["n2", "n3"],
|
|
);
|
|
});
|
|
|
|
test("buildVaultNoteMarkdownExportFiles preserves groups and de-duplicates file names", () => {
|
|
const notes = [
|
|
sanitizeVaultNote({ id: "n1", title: "Runbook", content: "# One", group: "Ops/DB", createdAt: 1, updatedAt: 1, order: 1000 }),
|
|
sanitizeVaultNote({ id: "n2", title: "Runbook", content: "# Two", group: "Ops/DB", createdAt: 1, updatedAt: 1, order: 2000 }),
|
|
sanitizeVaultNote({ id: "n3", title: "", content: "Untitled", createdAt: 1, updatedAt: 1, order: 3000 }),
|
|
sanitizeVaultNote({ id: "n4", title: "Outside", content: "Nope", group: "Other", createdAt: 1, updatedAt: 1, order: 4000 }),
|
|
];
|
|
|
|
const files = buildVaultNoteMarkdownExportFiles(notes, { type: "group", group: "Ops" });
|
|
assert.deepEqual(files, [
|
|
{ name: "Ops/DB/Runbook.md", content: "# One" },
|
|
{ name: "Ops/DB/Runbook-2.md", content: "# Two" },
|
|
]);
|
|
|
|
assert.equal(buildVaultNoteMarkdownExportFiles(notes)[2].name, "note-3.md");
|
|
});
|
|
|
|
test("buildVaultNoteMarkdownExportFiles keeps file names distinct from directory paths", () => {
|
|
const notes = [
|
|
sanitizeVaultNote({ id: "n1", title: "docs", content: "root", createdAt: 1, updatedAt: 1, order: 1000 }),
|
|
sanitizeVaultNote({ id: "n2", title: "child", content: "nested", group: "DOCS.md", createdAt: 1, updatedAt: 1, order: 2000 }),
|
|
];
|
|
|
|
assert.deepEqual(buildVaultNoteMarkdownExportFiles(notes), [
|
|
{ name: "docs-2.md", content: "root" },
|
|
{ name: "DOCS.md/child.md", content: "nested" },
|
|
]);
|
|
});
|
|
|
|
test("buildVaultNoteMarkdownExportFiles keeps sanitized group paths distinct", () => {
|
|
const notes = [
|
|
sanitizeVaultNote({ id: "n1", title: "US", content: "one", group: "Prod:US/Apps", createdAt: 1, updatedAt: 1, order: 1000 }),
|
|
sanitizeVaultNote({ id: "n2", title: "US", content: "two", group: "Prod?US/Apps", createdAt: 1, updatedAt: 1, order: 2000 }),
|
|
sanitizeVaultNote({ id: "n3", title: "EU", content: "three", group: "Prod:US/Apps?EU", createdAt: 1, updatedAt: 1, order: 3000 }),
|
|
sanitizeVaultNote({ id: "n4", title: "EU", content: "four", group: "Prod:US/Apps:EU", createdAt: 1, updatedAt: 1, order: 4000 }),
|
|
];
|
|
|
|
assert.deepEqual(buildVaultNoteMarkdownExportFiles(notes), [
|
|
{ name: "Prod-US/Apps/US.md", content: "one" },
|
|
{ name: "Prod-US-2/Apps/US.md", content: "two" },
|
|
{ name: "Prod-US/Apps-EU/EU.md", content: "three" },
|
|
{ name: "Prod-US/Apps-EU-2/EU.md", content: "four" },
|
|
]);
|
|
});
|
|
|
|
test("resolveRenderedMarkdownLinkHref recovers ssh links sanitized by the editor DOM", () => {
|
|
assert.equal(
|
|
resolveRenderedMarkdownLinkHref(
|
|
"Open [10.2.0.32](ssh://10.2.0.32) from notes",
|
|
"10.2.0.32",
|
|
"about:blank",
|
|
),
|
|
"ssh://10.2.0.32",
|
|
);
|
|
});
|
|
|
|
test("resolveRenderedMarkdownLinkHref keeps normal rendered links unchanged", () => {
|
|
assert.equal(
|
|
resolveRenderedMarkdownLinkHref(
|
|
"[Example](https://example.com)",
|
|
"Example",
|
|
"https://example.com/",
|
|
),
|
|
"https://example.com/",
|
|
);
|
|
});
|
|
|
|
test("resolveRenderedMarkdownLinkHref avoids guessing duplicate labels", () => {
|
|
assert.equal(
|
|
resolveRenderedMarkdownLinkHref(
|
|
"[host](ssh://10.0.0.1) [host](ssh://10.0.0.2)",
|
|
"host",
|
|
"about:blank",
|
|
),
|
|
"about:blank",
|
|
);
|
|
});
|
|
|
|
test("deriveNoteImportTitle prefers the first markdown heading", () => {
|
|
assert.equal(
|
|
deriveNoteImportTitle("runbook.md", "# Failover\n\nPromote replica"),
|
|
"Failover",
|
|
);
|
|
assert.equal(
|
|
deriveNoteImportTitle("deploy-notes.markdown", "No heading here"),
|
|
"deploy-notes",
|
|
);
|
|
assert.equal(
|
|
deriveNoteImportTitle("README.txt", ""),
|
|
"README",
|
|
);
|
|
assert.equal(
|
|
deriveNoteImportTitle("script.md", "```sh\n# not a title\n```\n\n# Real Title"),
|
|
"Real Title",
|
|
);
|
|
assert.equal(
|
|
deriveNoteImportTitle("tilde.md", "~~~md\n# not a title\n~~~\n\n# Tilde Fence Title"),
|
|
"Tilde Fence Title",
|
|
);
|
|
assert.equal(
|
|
deriveNoteImportTitle("long-fence.md", "````md\n# not a title\n```\nstill fenced\n````\n\n# Long Fence Title"),
|
|
"Long Fence Title",
|
|
);
|
|
assert.equal(
|
|
deriveNoteImportTitle("unclosed.md", "```sh\n# not a title\n\n# Also inside fence"),
|
|
"unclosed",
|
|
);
|
|
assert.equal(
|
|
deriveNoteImportTitle("unclosed-tilde.md", "~~~sh\n# not a title\n\n# Also inside fence"),
|
|
"unclosed-tilde",
|
|
);
|
|
assert.equal(
|
|
deriveNoteImportTitle("preface.md", "# Real Title\n\n```sh\n# not a title"),
|
|
"Real Title",
|
|
);
|
|
});
|
|
|
|
test("buildVaultNoteFromMarkdownImport creates a note in the target group", () => {
|
|
const note = buildVaultNoteFromMarkdownImport({
|
|
fileName: "runbook.md",
|
|
content: "# Runbook\n\nRestart sshd",
|
|
group: "Ops",
|
|
order: 1000,
|
|
});
|
|
|
|
assert.equal(note.title, "Runbook");
|
|
assert.equal(note.content, "# Runbook\n\nRestart sshd");
|
|
assert.equal(note.group, "Ops");
|
|
assert.equal(note.order, 1000);
|
|
});
|
|
|
|
test("importMarkdownPayloadsToVaultNotes appends notes from pre-read payloads", () => {
|
|
const existing = [sanitizeVaultNote({
|
|
id: "existing",
|
|
title: "Existing",
|
|
content: "body",
|
|
createdAt: 1,
|
|
updatedAt: 1,
|
|
order: 1000,
|
|
})];
|
|
|
|
const result = importMarkdownPayloadsToVaultNotes(
|
|
[{ fileName: "imported.md", content: "# Imported\n\nBody" }],
|
|
existing,
|
|
"Ops",
|
|
);
|
|
|
|
assert.equal(result.importedCount, 1);
|
|
assert.equal(result.notes.length, 2);
|
|
assert.equal(result.notes[1].title, "Imported");
|
|
assert.equal(result.notes[1].group, "Ops");
|
|
});
|
|
|
|
test("importMarkdownPayloadsToVaultNotes prefers an explicit title over the first heading", () => {
|
|
const result = importMarkdownPayloadsToVaultNotes(
|
|
[{ fileName: "imported.md", content: "# Heading\n\nBody", title: "Runbook" }],
|
|
[],
|
|
null,
|
|
);
|
|
|
|
assert.equal(result.importedCount, 1);
|
|
assert.equal(result.notes[0].title, "Runbook");
|
|
assert.equal(result.notes[0].content, "# Heading\n\nBody");
|
|
});
|
|
|
|
test("importMarkdownFilesToVaultNotes appends notes and skips unsupported files", async () => {
|
|
const existing = [sanitizeVaultNote({
|
|
id: "existing",
|
|
title: "Existing",
|
|
content: "body",
|
|
createdAt: 1,
|
|
updatedAt: 1,
|
|
order: 1000,
|
|
})];
|
|
const files = [
|
|
new File(["# Imported\n\nBody"], "imported.md", { type: "text/markdown" }),
|
|
new File(["ignored"], "notes.json", { type: "application/json" }),
|
|
];
|
|
|
|
const result = await importMarkdownFilesToVaultNotes(
|
|
files,
|
|
existing,
|
|
"Ops",
|
|
async (file) => file.text(),
|
|
);
|
|
|
|
assert.equal(result.importedCount, 1);
|
|
assert.equal(result.skippedCount, 1);
|
|
assert.equal(result.notes.length, 2);
|
|
assert.equal(result.notes[1].title, "Imported");
|
|
assert.equal(result.notes[1].group, "Ops");
|
|
});
|
|
|
|
test("extractNoteHeadings extracts markdown headings ignoring code blocks", () => {
|
|
const content = `# Title 1
|
|
Some intro text
|
|
\`\`\`ts
|
|
# Not a heading
|
|
\`\`\`
|
|
## Subtitle 1.1
|
|
### Deep section
|
|
`;
|
|
const headings = extractNoteHeadings(content);
|
|
assert.equal(headings.length, 3);
|
|
assert.equal(headings[0].text, "Title 1");
|
|
assert.equal(headings[0].level, 1);
|
|
assert.equal(headings[1].text, "Subtitle 1.1");
|
|
assert.equal(headings[1].level, 2);
|
|
assert.equal(headings[2].text, "Deep section");
|
|
assert.equal(headings[2].level, 3);
|
|
});
|
|
|
|
test("extractNoteHeadings follows rendered markdown fence and setext rules", () => {
|
|
const content = `Setext title
|
|
============
|
|
|
|
~~~md
|
|
# Hidden in tilde fence
|
|
~~~
|
|
|
|
\`\`\`\`md
|
|
## Hidden in long fence
|
|
\`\`\`
|
|
still hidden
|
|
\`\`\`\`
|
|
|
|
# Indented code
|
|
### Visible ###`;
|
|
const headings = extractNoteHeadings(content);
|
|
|
|
assert.deepEqual(
|
|
headings.map(({ level, text, line }) => ({ level, text, line })),
|
|
[
|
|
{ level: 1, text: "Setext title", line: 1 },
|
|
{ level: 3, text: "Visible", line: 15 },
|
|
],
|
|
);
|
|
});
|
|
|
|
test("extractNoteHeadings does not turn thematic breaks after block headings into setext headings", () => {
|
|
assert.deepEqual(
|
|
extractNoteHeadings("# First\n---\n## Second").map(({ level, text }) => ({ level, text })),
|
|
[
|
|
{ level: 1, text: "First" },
|
|
{ level: 2, text: "Second" },
|
|
],
|
|
);
|
|
});
|
|
|
|
test("extractNoteHeadings excludes reference definitions before thematic breaks", () => {
|
|
assert.deepEqual(
|
|
extractNoteHeadings("[docs]: https://example.com\n---\n## Real").map(({ text }) => text),
|
|
["Real"],
|
|
);
|
|
});
|
|
|
|
test("extractNoteHeadings uses the same visible text as formatted rendered headings", () => {
|
|
assert.deepEqual(
|
|
extractNoteHeadings("## **Bold**\n## ~~Removed~~ title\n## [Docs](https://example.com)\n## `code` © more\n## <https://example.com>\n## [Reference][docs]\n\n[docs]: /url")
|
|
.map(({ text }) => text),
|
|
["Bold", "Removed title", "Docs", "code © more", "https://example.com", "Reference"],
|
|
);
|
|
});
|
|
|
|
test("extractNoteHeadings includes headings rendered inside markdown containers", () => {
|
|
assert.deepEqual(
|
|
extractNoteHeadings("> ## Repeat\n## Repeat\n- ### Listed").map(({ level, text }) => ({ level, text })),
|
|
[
|
|
{ level: 2, text: "Repeat" },
|
|
{ level: 2, text: "Repeat" },
|
|
{ level: 3, text: "Listed" },
|
|
],
|
|
);
|
|
});
|
|
|
|
test("extractNoteHeadings keeps complete multi-line setext heading text", () => {
|
|
const [heading] = extractNoteHeadings("first line\nsecond line\n---");
|
|
assert.deepEqual(
|
|
{ level: heading.level, text: heading.text, line: heading.line },
|
|
{ level: 2, text: "first line second line", line: 1 },
|
|
);
|
|
});
|
|
|
|
test("extractNoteHeadings ignores multi-line definitions and raw HTML blocks", () => {
|
|
assert.deepEqual(
|
|
extractNoteHeadings('[foo]: /url\n "title"\n---\n\n<div>\ntext\n---\n</div>\n\n## Real').map(({ text }) => text),
|
|
["Real"],
|
|
);
|
|
});
|
|
|
|
test("extractNoteSnippet extracts clean plain text from markdown", () => {
|
|
const content = `# Title
|
|
Here is **bold** text and [a link](https://example.com) and \`code\`.
|
|
- [x] Task 1
|
|
> quote text
|
|
`;
|
|
const snippet = extractNoteSnippet(content, 100);
|
|
assert.ok(!snippet.includes("#"));
|
|
assert.ok(!snippet.includes("[a link]"));
|
|
assert.ok(snippet.includes("bold"));
|
|
assert.ok(snippet.includes("Task 1"));
|
|
});
|
|
|
|
test("extractAllNoteTags aggregates and sorts tags by frequency", () => {
|
|
const notes = [
|
|
sanitizeVaultNote({ tags: ["dev", "prod"] }),
|
|
sanitizeVaultNote({ tags: ["dev", "staging"] }),
|
|
sanitizeVaultNote({ tags: ["dev"] }),
|
|
];
|
|
const tags = extractAllNoteTags(notes);
|
|
assert.equal(tags[0].tag, "dev");
|
|
assert.equal(tags[0].count, 3);
|
|
});
|
|
|
|
test("filterAndSortVaultNotes filters by pinned, tags, group and sorts accordingly", () => {
|
|
const notes = [
|
|
sanitizeVaultNote({ id: "1", title: "B Note", isPinned: false, updatedAt: 100, tags: ["ssh"] }),
|
|
sanitizeVaultNote({ id: "2", title: "A Note", isPinned: true, updatedAt: 50, tags: ["ssh"] }),
|
|
sanitizeVaultNote({ id: "3", title: "C Note", isPinned: false, updatedAt: 200, group: "Ops" }),
|
|
];
|
|
|
|
// Pinned first
|
|
const sorted = filterAndSortVaultNotes(notes, { sort: "updatedDesc" });
|
|
assert.equal(sorted[0].id, "2"); // Pinned note first
|
|
assert.equal(sorted[1].id, "3"); // 200 updatedAt
|
|
assert.equal(sorted[2].id, "1"); // 100 updatedAt
|
|
|
|
// Filter pinned only
|
|
const pinnedOnly = filterAndSortVaultNotes(notes, { filterMode: "pinned" });
|
|
assert.equal(pinnedOnly.length, 1);
|
|
assert.equal(pinnedOnly[0].id, "2");
|
|
|
|
// Filter by tag
|
|
const tagFiltered = filterAndSortVaultNotes(notes, { tag: "ssh" });
|
|
assert.equal(tagFiltered.length, 2);
|
|
});
|
|
|
|
test("calculateNoteStats calculates lines, chars, and word counts", () => {
|
|
const content = "Hello world\n这是中文测试内容\nThird line";
|
|
const stats = calculateNoteStats(content);
|
|
assert.equal(stats.lines, 3);
|
|
assert.equal(stats.chars, content.length);
|
|
// Hello(1) + world(1) + 8 CJK chars + Third(1) + line(1) = 12
|
|
assert.equal(stats.words, 12);
|
|
});
|
|
|
|
test("wrapMarkdownSyntax wraps or inserts markdown syntax correctly", () => {
|
|
const base = "Hello world";
|
|
// bold on 'world' (start 6, end 11)
|
|
const boldRes = wrapMarkdownSyntax(base, 6, 11, "bold");
|
|
assert.equal(boldRes.text, "Hello **world**");
|
|
|
|
// insert table when no selection (start 0, end 0)
|
|
const tableRes = wrapMarkdownSyntax("", 0, 0, "table");
|
|
assert.ok(tableRes.text.includes("| Column 1 | Column 2 | Column 3 |"));
|
|
|
|
// insert code block
|
|
const codeRes = wrapMarkdownSyntax("", 0, 0, "codeblock");
|
|
assert.ok(codeRes.text.includes("```bash"));
|
|
assert.equal(codeRes.selectionStart, "\n```bash\n".length);
|
|
assert.equal(codeRes.selectionEnd, "\n```bash\n".length);
|
|
|
|
// insert math block
|
|
const mathRes = wrapMarkdownSyntax("", 0, 0, "math");
|
|
assert.ok(mathRes.text.includes("```latex"));
|
|
assert.equal(mathRes.selectionStart, "\n```latex\n".length);
|
|
assert.equal(mathRes.selectionEnd, "\n```latex\n".length);
|
|
|
|
const selectedCodeRes = wrapMarkdownSyntax("echo ok", 0, 7, "codeblock");
|
|
assert.equal(
|
|
selectedCodeRes.text.slice(selectedCodeRes.selectionStart, selectedCodeRes.selectionEnd),
|
|
"echo ok",
|
|
);
|
|
|
|
const selectedMathRes = wrapMarkdownSyntax("x^2", 0, 3, "math");
|
|
assert.equal(
|
|
selectedMathRes.text.slice(selectedMathRes.selectionStart, selectedMathRes.selectionEnd),
|
|
"x^2",
|
|
);
|
|
|
|
const bulletRes = wrapMarkdownSyntax("one\ntwo", 0, 7, "bullet");
|
|
assert.equal(bulletRes.text, "\n- one\n- two\n");
|
|
assert.equal(
|
|
bulletRes.text.slice(bulletRes.selectionStart, bulletRes.selectionEnd),
|
|
"one\n- two",
|
|
);
|
|
|
|
const numberRes = wrapMarkdownSyntax("one\ntwo", 0, 7, "number");
|
|
assert.equal(numberRes.text, "\n1. one\n2. two\n");
|
|
assert.equal(
|
|
numberRes.text.slice(numberRes.selectionStart, numberRes.selectionEnd),
|
|
"one\n2. two",
|
|
);
|
|
|
|
const taskRes = wrapMarkdownSyntax("one\ntwo", 0, 7, "task");
|
|
assert.equal(taskRes.text, "\n- [ ] one\n- [ ] two\n");
|
|
assert.equal(
|
|
taskRes.text.slice(taskRes.selectionStart, taskRes.selectionEnd),
|
|
"one\n- [ ] two",
|
|
);
|
|
|
|
const quoteRes = wrapMarkdownSyntax("one\n\ntwo", 0, 8, "quote");
|
|
assert.equal(quoteRes.text, "\n> one\n>\n> two\n");
|
|
assert.equal(
|
|
quoteRes.text.slice(quoteRes.selectionStart, quoteRes.selectionEnd),
|
|
"one\n>\n> two",
|
|
);
|
|
|
|
const trailingNewlineQuoteRes = wrapMarkdownSyntax("one\ntwo\nthree", 0, 8, "quote");
|
|
assert.equal(trailingNewlineQuoteRes.text, "\n> one\n> two\n>\nthree");
|
|
assert.equal(
|
|
trailingNewlineQuoteRes.text.slice(
|
|
trailingNewlineQuoteRes.selectionStart,
|
|
trailingNewlineQuoteRes.selectionEnd,
|
|
),
|
|
"one\n> two",
|
|
);
|
|
|
|
const leadingNewlineQuoteRes = wrapMarkdownSyntax("\none", 0, 4, "quote");
|
|
assert.equal(leadingNewlineQuoteRes.text, "\n>\n> one\n");
|
|
assert.equal(
|
|
leadingNewlineQuoteRes.text.slice(
|
|
leadingNewlineQuoteRes.selectionStart,
|
|
leadingNewlineQuoteRes.selectionEnd,
|
|
),
|
|
"one",
|
|
);
|
|
|
|
const newlineOnlyQuoteRes = wrapMarkdownSyntax("\n", 0, 1, "quote");
|
|
assert.equal(newlineOnlyQuoteRes.text, "\n> Quote\n");
|
|
assert.equal(
|
|
newlineOnlyQuoteRes.text.slice(newlineOnlyQuoteRes.selectionStart, newlineOnlyQuoteRes.selectionEnd),
|
|
"Quote",
|
|
);
|
|
|
|
const trailingNewlineBulletRes = wrapMarkdownSyntax("one\ntwo\nthree", 0, 8, "bullet");
|
|
assert.equal(trailingNewlineBulletRes.text, "\n- one\n- two\n\nthree");
|
|
assert.equal(
|
|
trailingNewlineBulletRes.text.slice(
|
|
trailingNewlineBulletRes.selectionStart,
|
|
trailingNewlineBulletRes.selectionEnd,
|
|
),
|
|
"one\n- two",
|
|
);
|
|
assert.doesNotMatch(
|
|
wrapMarkdownSyntax("one\ntwo\nthree", 0, 8, "number").text,
|
|
/^3\.\s*$/m,
|
|
);
|
|
assert.doesNotMatch(
|
|
wrapMarkdownSyntax("one\ntwo\nthree", 0, 8, "task").text,
|
|
/^- \[ \]\s*$/m,
|
|
);
|
|
|
|
const blankLinesNumberRes = wrapMarkdownSyntax("one\n\ntwo\n\n\nthree", 0, 11, "number");
|
|
assert.equal(blankLinesNumberRes.text, "\n1. one\n\n2. two\n\n\n\nthree");
|
|
assert.equal(
|
|
blankLinesNumberRes.text.slice(
|
|
blankLinesNumberRes.selectionStart,
|
|
blankLinesNumberRes.selectionEnd,
|
|
),
|
|
"one\n\n2. two",
|
|
);
|
|
|
|
for (const action of ["bullet", "number", "task"] as const) {
|
|
const newlineOnlyRes = wrapMarkdownSyntax("\n", 0, 1, action);
|
|
const expected = action === "bullet" ? "- List item" : action === "number" ? "1. List item" : "- [ ] Task";
|
|
assert.equal(newlineOnlyRes.text, `\n${expected}\n`);
|
|
assert.equal(
|
|
newlineOnlyRes.text.slice(newlineOnlyRes.selectionStart, newlineOnlyRes.selectionEnd),
|
|
action === "task" ? "Task" : "List item",
|
|
);
|
|
}
|
|
});
|
|
|
|
test("formatMarkdownListSelection prefixes every non-empty selected line", () => {
|
|
assert.equal(formatMarkdownListSelection("one\ntwo", "bullet"), "- one\n- two");
|
|
assert.equal(formatMarkdownListSelection("one\n\ntwo", "number"), "1. one\n\n2. two");
|
|
assert.equal(formatMarkdownListSelection("one\ntwo", "task"), "- [ ] one\n- [ ] two");
|
|
});
|
|
|
|
test("formatMarkdownQuoteSelection prefixes every selected line", () => {
|
|
assert.equal(formatMarkdownQuoteSelection("one\n\ntwo"), "> one\n>\n> two");
|
|
});
|
|
|
|
test("note mention index preserves search fields, entity identity and edited snapshots", () => {
|
|
const notes = [
|
|
{ id: "a", title: "Same", content: "Alpha body", group: "Production", tags: ["API"], createdAt: 1, updatedAt: 1 },
|
|
{ id: "b", title: "Same", content: "Beta body", createdAt: 1, updatedAt: 1 },
|
|
];
|
|
const search = createVaultNoteSearchIndex(notes);
|
|
for (const query of ["", " SAME ", "ALPHA", "beta", "production", "api", "missing", "same alpha"]) {
|
|
assert.deepEqual(search(query), notes.filter((note) => matchesVaultNoteSearch(note, query)));
|
|
}
|
|
assert.equal(search("beta")[0], notes[1]);
|
|
const edited = [{ ...notes[0], content: "Replacement" }, notes[1]];
|
|
assert.deepEqual(createVaultNoteSearchIndex(edited)("alpha"), []);
|
|
assert.equal(createVaultNoteSearchIndex(edited)("replacement")[0], edited[0]);
|
|
});
|