459 lines
21 KiB
JavaScript
459 lines
21 KiB
JavaScript
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import {
|
|
BUILTINS,
|
|
commands,
|
|
globalCommands,
|
|
historyCommands,
|
|
menuNotes,
|
|
} from "../herdr/herdr-composer/mods/herdr-composer/catalog.js";
|
|
import {
|
|
DEFAULT_PROFILES,
|
|
resolveProfile,
|
|
} from "../herdr/herdr-composer/mods/herdr-composer/profiles.js";
|
|
import {
|
|
GROUPS,
|
|
GROUP_HISTORY,
|
|
GROUP_USER,
|
|
GROUP_PLUGIN,
|
|
} from "../herdr/herdr-composer/mods/herdr-composer/suggest.js";
|
|
|
|
const HOME = "C:/Users/Test";
|
|
const CC_PROFILE = DEFAULT_PROFILES[0];
|
|
const CC = CC_PROFILE.sources;
|
|
|
|
/**
|
|
* A fake machine: `files` maps a path to its text. `exec` answers the POSIX
|
|
* listing of catalog.js (powershell is "not installed"), `readText` reads.
|
|
*/
|
|
function machine(files, { listError = false } = {}) {
|
|
const exec = async (command, args) => {
|
|
if (command !== "sh") throw new Error("not found");
|
|
if (listError) return { code: 2, stdout: "", stderr: "boom" };
|
|
const rest = args.slice(3);
|
|
const lines = [];
|
|
for (let i = 0; i + 2 < rest.length; i += 3) {
|
|
const [index, kind, path] = rest.slice(i, i + 3);
|
|
for (const file of Object.keys(files)) {
|
|
const name = file.slice(file.lastIndexOf("/") + 1);
|
|
const dir = file.slice(0, file.lastIndexOf("/"));
|
|
if (kind === "file" && file === path) lines.push(`${index}\t${file}`);
|
|
if (kind === "md" && dir === path && name.endsWith(".md")) lines.push(`${index}\t${file}`);
|
|
if (kind === "skills" && name === "SKILL.md" && dir.slice(0, dir.lastIndexOf("/")) === path)
|
|
lines.push(`${index}\t${file}`);
|
|
}
|
|
}
|
|
return { code: 0, stdout: lines.join("\n"), stderr: "" };
|
|
};
|
|
const readText = async (path) => files[path] ?? null;
|
|
return { exec, readText };
|
|
}
|
|
|
|
const skill = (name, extra = "") => `---\nname: ${name}\ndescription: Opis ${name}\n${extra}---\nTreść\n`;
|
|
|
|
function plugins(enabled, installed) {
|
|
return {
|
|
[`${HOME}/.claude/settings.json`]: JSON.stringify({ enabledPlugins: enabled }),
|
|
[`${HOME}/.claude/plugins/installed_plugins.json`]: JSON.stringify({
|
|
version: 2,
|
|
plugins: Object.fromEntries(
|
|
Object.entries(installed).map(([id, path]) => [id, [{ installPath: path }]]),
|
|
),
|
|
}),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* One fake machine for the project (relative paths, `cwd` given) and the
|
|
* person's home (absolute paths). It answers the POSIX scripts of catalog.js:
|
|
* the old fixed project listing, and the listing by (index, kind, path)
|
|
* triples; PowerShell is "not installed".
|
|
*/
|
|
function ccMachine(files) {
|
|
const inner = machine(files);
|
|
const match = (index, kind, path) => {
|
|
const lines = [];
|
|
for (const file of Object.keys(files)) {
|
|
const name = file.slice(file.lastIndexOf("/") + 1);
|
|
const dir = file.slice(0, file.lastIndexOf("/"));
|
|
if (kind === "file" && file === path) lines.push(`${index}\t${file}`);
|
|
if (kind === "md" && dir === path && name.endsWith(".md")) lines.push(`${index}\t${file}`);
|
|
if (kind === "skills" && name === "SKILL.md" && dir.slice(0, dir.lastIndexOf("/")) === path)
|
|
lines.push(`${index}\t${file}`);
|
|
}
|
|
return lines;
|
|
};
|
|
const exec = async (command, args, options = {}) => {
|
|
if (command !== "sh") throw new Error("not found");
|
|
const rest = args.slice(3);
|
|
// the new listing of a profile's project sources: the same triples
|
|
if (options.cwd && rest.length > 0 && rest.length % 3 === 0 && /^\d+$/.test(rest[0])) {
|
|
const lines = [];
|
|
for (let i = 0; i < rest.length; i += 3) lines.push(...match(rest[i], rest[i + 1], rest[i + 2]));
|
|
return { code: 0, stdout: lines.join("\n"), stderr: "" };
|
|
}
|
|
// the old fixed listing of the project
|
|
if (options.cwd && rest.length === 0) {
|
|
const stdout = Object.keys(files)
|
|
.filter((f) => /^\.claude\/(commands\/[^/]+\.md|skills\/[^/]+\/SKILL\.md)$/.test(f))
|
|
.join("\n");
|
|
return { code: 0, stdout, stderr: "" };
|
|
}
|
|
// a read of one file
|
|
if (rest.length === 1) {
|
|
const text = files[rest[0]];
|
|
return text === undefined ? { code: 1, stdout: "", stderr: "" } : { code: 0, stdout: text, stderr: "" };
|
|
}
|
|
return inner.exec(command, args, options);
|
|
};
|
|
return { exec, readText: inner.readText };
|
|
}
|
|
|
|
const CC_FILES = {
|
|
".claude/commands/a.md": "---\ndescription: Komenda a\n---\nTreść\n",
|
|
".claude/skills/s/SKILL.md": skill("inna"),
|
|
[`${HOME}/.claude/commands/handoff.md`]: "---\ndescription: Przekazanie\n---\nTreść\n",
|
|
...plugins({ "sp@official": true }, { "sp@official": "C:\\p\\sp" }),
|
|
"C:/p/sp/skills/brainstorming/SKILL.md": skill("brainstorming"),
|
|
};
|
|
|
|
const ccRow = (item) => ({ key: item.key, group: item.group, insert: item.insert, desc: item.desc });
|
|
|
|
test("GROUPS has Pluginy right after Użytkownik", () => {
|
|
assert.equal(GROUPS[GROUPS.indexOf(GROUP_USER) + 1], "Pluginy");
|
|
assert.equal(GROUP_PLUGIN, "Pluginy");
|
|
});
|
|
|
|
test("claude-code builtins: the full list, unique keys", () => {
|
|
const keys = BUILTINS["claude-code"].map((item) => item.key);
|
|
for (const key of ["context", "help", "mcp", "rewind", "clear"]) assert.ok(keys.includes(key), key);
|
|
assert.equal(new Set(keys).size, keys.length);
|
|
assert.deepEqual(keys, [...keys].sort());
|
|
});
|
|
|
|
test("globalCommands: an enabled plugin gives plugin:name (default skills dir)", async () => {
|
|
const dir = "C:/p/superpowers/7.0.2";
|
|
const { exec, readText } = machine({
|
|
...plugins({ "superpowers@official": true }, { "superpowers@official": "C:\\p\\superpowers\\7.0.2" }),
|
|
[`${dir}/skills/brainstorming/SKILL.md`]: skill("brainstorming"),
|
|
});
|
|
const items = await globalCommands(HOME, exec, readText, { sources: CC });
|
|
assert.equal(items.length, 1);
|
|
assert.equal(items[0].key, "superpowers:brainstorming");
|
|
assert.equal(items[0].group, GROUP_PLUGIN);
|
|
assert.equal(items[0].insert, "/superpowers:brainstorming ");
|
|
assert.equal(items[0].desc, "Opis brainstorming");
|
|
});
|
|
|
|
test("globalCommands: disabled or unlisted plugin gives nothing", async () => {
|
|
const dir = "C:/p/a/1";
|
|
const { exec, readText } = machine({
|
|
...plugins({ "a@m": false }, { "a@m": dir, "b@m": "C:/p/b/1" }),
|
|
[`${dir}/skills/x/SKILL.md`]: skill("x"),
|
|
["C:/p/b/1/skills/y/SKILL.md"]: skill("y"),
|
|
});
|
|
assert.deepEqual(await globalCommands(HOME, exec, readText, { sources: CC }), []);
|
|
});
|
|
|
|
test("globalCommands: plugin.json skills array takes only the named dirs", async () => {
|
|
const dir = "C:/p/mp/1";
|
|
const { exec, readText } = machine({
|
|
...plugins({ "mp@m": true }, { "mp@m": dir }),
|
|
[`${dir}/.claude-plugin/plugin.json`]: JSON.stringify({ skills: ["./skills/eng/tdd"] }),
|
|
[`${dir}/skills/eng/tdd/SKILL.md`]: skill("tdd"),
|
|
[`${dir}/skills/eng/other/SKILL.md`]: skill("other"),
|
|
[`${dir}/skills/direct/SKILL.md`]: skill("direct"),
|
|
});
|
|
const keys = (await globalCommands(HOME, exec, readText, { sources: CC })).map((item) => item.key);
|
|
assert.deepEqual(keys, ["mp:tdd"]);
|
|
});
|
|
|
|
test("globalCommands: plugin commands dir and user-invocable false", async () => {
|
|
const dir = "C:/p/c/1";
|
|
const { exec, readText } = machine({
|
|
...plugins({ "c@m": true }, { "c@m": dir }),
|
|
[`${dir}/commands/ship.md`]: "---\ndescription: Wysyła\n---\n",
|
|
[`${dir}/skills/hidden/SKILL.md`]: skill("hidden", "user-invocable: false\n"),
|
|
[`${dir}/skills/shown/SKILL.md`]: skill("shown"),
|
|
});
|
|
const keys = (await globalCommands(HOME, exec, readText, { sources: CC })).map((item) => item.key).sort();
|
|
assert.deepEqual(keys, ["c:ship", "c:shown"]);
|
|
});
|
|
|
|
test("globalCommands: name: in the front matter wins over the folder name", async () => {
|
|
const { exec, readText } = machine({
|
|
[`${HOME}/.claude/skills/folder/SKILL.md`]: skill("real-name"),
|
|
});
|
|
const items = await globalCommands(HOME, exec, readText, { sources: CC });
|
|
assert.deepEqual(items.map((item) => item.key), ["real-name"]);
|
|
});
|
|
|
|
test("globalCommands: a user command gives handoff in Użytkownik", async () => {
|
|
const { exec, readText } = machine({
|
|
[`${HOME}/.claude/commands/handoff.md`]: "---\ndescription: Przekazanie\n---\n",
|
|
});
|
|
const items = await globalCommands(HOME, exec, readText, { sources: CC });
|
|
assert.equal(items.length, 1);
|
|
assert.equal(items[0].key, "handoff");
|
|
assert.equal(items[0].group, GROUP_USER);
|
|
assert.equal(items[0].insert, "/handoff ");
|
|
});
|
|
|
|
test("globalCommands: no settings.json, broken json: user items only, no throw", async () => {
|
|
const none = machine({ [`${HOME}/.claude/commands/a.md`]: "x" });
|
|
assert.deepEqual((await globalCommands(HOME, none.exec, none.readText, { sources: CC })).map((i) => i.key), ["a"]);
|
|
|
|
const broken = machine({
|
|
[`${HOME}/.claude/settings.json`]: "{nope",
|
|
[`${HOME}/.claude/plugins/installed_plugins.json`]: "[[",
|
|
[`${HOME}/.claude/commands/a.md`]: "x",
|
|
});
|
|
assert.deepEqual((await globalCommands(HOME, broken.exec, broken.readText, { sources: CC })).map((i) => i.key), ["a"]);
|
|
});
|
|
|
|
test("globalCommands: a listing failure goes to onReadError, or throws", async () => {
|
|
const { exec, readText } = machine({}, { listError: true });
|
|
const errors = [];
|
|
const items = await globalCommands(HOME, exec, readText, { sources: CC, onReadError: (err) => errors.push(err) });
|
|
assert.deepEqual(items, []);
|
|
assert.equal(errors.length, 1);
|
|
await assert.rejects(() => globalCommands(HOME, exec, readText, { sources: CC }));
|
|
});
|
|
|
|
test("paths with spaces and Polish letters are not put in the PowerShell script as text", async () => {
|
|
const home = "D:/Użytkownik Zażółć/x";
|
|
let script = "";
|
|
const exec = async (command, args) => {
|
|
if (command === "powershell") {
|
|
script = args[args.length - 1];
|
|
return { code: 0, stdout: "", stderr: "" };
|
|
}
|
|
throw new Error("no");
|
|
};
|
|
await globalCommands(home, exec, async () => null, { sources: CC });
|
|
assert.ok(script.length > 0);
|
|
assert.ok(!script.includes("Zażółć"));
|
|
});
|
|
|
|
test("commands: options.global joins after the project, first key wins", async () => {
|
|
const exec = async () => ({ code: 0, stdout: "", stderr: "" });
|
|
const global = [
|
|
{ key: "clear", desc: "dup", group: GROUP_USER, insert: "/clear " },
|
|
{ key: "handoff", desc: "h", group: GROUP_USER, insert: "/handoff " },
|
|
];
|
|
const items = await commands("/x", exec, { profile: CC_PROFILE, global });
|
|
assert.equal(items.filter((item) => item.key === "clear").length, 1);
|
|
assert.equal(
|
|
items.find((item) => item.key === "clear").desc,
|
|
BUILTINS["claude-code"].find((item) => item.key === "clear").desc,
|
|
);
|
|
assert.ok(items.some((item) => item.key === "handoff"));
|
|
});
|
|
|
|
test("commands: codex gets its builtins and snippets - no project sources, no exec", async () => {
|
|
let calls = 0;
|
|
const exec = async () => {
|
|
calls += 1;
|
|
return { code: 0, stdout: "", stderr: "" };
|
|
};
|
|
const items = await commands("/x", exec, {
|
|
profile: resolveProfile([], "codex"),
|
|
snippets: [{ key: "mine", desc: "s" }],
|
|
});
|
|
assert.equal(calls, 0);
|
|
const keys = items.map((item) => item.key);
|
|
assert.deepEqual(keys, [...BUILTINS.codex.map((item) => item.key), "mine"]);
|
|
});
|
|
|
|
test("commands: claude-code still reads the project and takes the global ones", async () => {
|
|
const { exec } = ccMachine({ ".claude/commands/p.md": "x" });
|
|
const global = [{ key: "handoff", desc: "h", group: GROUP_USER, insert: "/handoff " }];
|
|
const items = await commands("/x", exec, { profile: resolveProfile([], "claude"), global });
|
|
const keys = items.map((item) => item.key);
|
|
assert.ok(keys.includes("handoff"));
|
|
assert.ok(keys.includes("clear"));
|
|
});
|
|
|
|
const EXPECTED_CC = [
|
|
{"key":"add-dir","group":"Wbudowane","insert":"/add-dir ","desc":"Dodaje katalog roboczy."},
|
|
{"key":"agents","group":"Wbudowane","insert":"/agents ","desc":"Zarządza subagentami."},
|
|
{"key":"bashes","group":"Wbudowane","insert":"/bashes ","desc":"Pokazuje zadania w tle."},
|
|
{"key":"bug","group":"Wbudowane","insert":"/bug ","desc":"Zgłasza błąd Claude Code."},
|
|
{"key":"clear","group":"Wbudowane","insert":"/clear ","desc":"Czyści historię rozmowy."},
|
|
{"key":"code-review","group":"Wbudowane","insert":"/code-review ","desc":"Przegląd zmian pod kątem błędów."},
|
|
{"key":"compact","group":"Wbudowane","insert":"/compact ","desc":"Zwija historię do podsumowania."},
|
|
{"key":"config","group":"Wbudowane","insert":"/config ","desc":"Otwiera ustawienia."},
|
|
{"key":"context","group":"Wbudowane","insert":"/context ","desc":"Pokazuje zużycie kontekstu."},
|
|
{"key":"cost","group":"Wbudowane","insert":"/cost ","desc":"Pokazuje koszt i zużycie tokenów."},
|
|
{"key":"doctor","group":"Wbudowane","insert":"/doctor ","desc":"Sprawdza instalację Claude Code."},
|
|
{"key":"exit","group":"Wbudowane","insert":"/exit ","desc":"Kończy sesję."},
|
|
{"key":"export","group":"Wbudowane","insert":"/export ","desc":"Eksportuje rozmowę."},
|
|
{"key":"fast","group":"Wbudowane","insert":"/fast ","desc":"Przełącza tryb szybki."},
|
|
{"key":"feedback","group":"Wbudowane","insert":"/feedback ","desc":"Wysyła opinię o Claude Code."},
|
|
{"key":"fewer-permission-prompts","group":"Wbudowane","insert":"/fewer-permission-prompts ","desc":"Dodaje bezpieczne komendy do listy dozwolonych."},
|
|
{"key":"help","group":"Wbudowane","insert":"/help ","desc":"Pomoc."},
|
|
{"key":"hooks","group":"Wbudowane","insert":"/hooks ","desc":"Zarządza hookami."},
|
|
{"key":"ide","group":"Wbudowane","insert":"/ide ","desc":"Łączy z IDE."},
|
|
{"key":"init","group":"Wbudowane","insert":"/init ","desc":"Tworzy CLAUDE.md dla projektu."},
|
|
{"key":"install-github-app","group":"Wbudowane","insert":"/install-github-app ","desc":"Instaluje aplikację GitHub."},
|
|
{"key":"keybindings","group":"Wbudowane","insert":"/keybindings ","desc":"Ustawia skróty klawiszowe."},
|
|
{"key":"login","group":"Wbudowane","insert":"/login ","desc":"Logowanie."},
|
|
{"key":"logout","group":"Wbudowane","insert":"/logout ","desc":"Wylogowanie."},
|
|
{"key":"loop","group":"Wbudowane","insert":"/loop ","desc":"Uruchamia polecenie cyklicznie."},
|
|
{"key":"mcp","group":"Wbudowane","insert":"/mcp ","desc":"Zarządza serwerami MCP."},
|
|
{"key":"memory","group":"Wbudowane","insert":"/memory ","desc":"Edytuje pliki pamięci."},
|
|
{"key":"model","group":"Wbudowane","insert":"/model ","desc":"Wybiera model."},
|
|
{"key":"output-style","group":"Wbudowane","insert":"/output-style ","desc":"Ustawia styl odpowiedzi."},
|
|
{"key":"permissions","group":"Wbudowane","insert":"/permissions ","desc":"Ustawia uprawnienia narzędzi."},
|
|
{"key":"plugin","group":"Wbudowane","insert":"/plugin ","desc":"Zarządza pluginami."},
|
|
{"key":"pr-comments","group":"Wbudowane","insert":"/pr-comments ","desc":"Pokazuje komentarze PR."},
|
|
{"key":"privacy-settings","group":"Wbudowane","insert":"/privacy-settings ","desc":"Ustawienia prywatności."},
|
|
{"key":"release-notes","group":"Wbudowane","insert":"/release-notes ","desc":"Pokazuje informacje o wydaniu."},
|
|
{"key":"resume","group":"Wbudowane","insert":"/resume ","desc":"Wznawia wcześniejszą sesję."},
|
|
{"key":"review","group":"Wbudowane","insert":"/review ","desc":"Przegląd pull requesta."},
|
|
{"key":"rewind","group":"Wbudowane","insert":"/rewind ","desc":"Cofa rozmowę lub kod."},
|
|
{"key":"schedule","group":"Wbudowane","insert":"/schedule ","desc":"Planuje zadania w chmurze."},
|
|
{"key":"security-review","group":"Wbudowane","insert":"/security-review ","desc":"Przegląd bezpieczeństwa zmian."},
|
|
{"key":"simplify","group":"Wbudowane","insert":"/simplify ","desc":"Upraszcza zmieniony kod."},
|
|
{"key":"status","group":"Wbudowane","insert":"/status ","desc":"Pokazuje stan sesji."},
|
|
{"key":"statusline","group":"Wbudowane","insert":"/statusline ","desc":"Ustawia linię statusu."},
|
|
{"key":"terminal-setup","group":"Wbudowane","insert":"/terminal-setup ","desc":"Konfiguruje terminal."},
|
|
{"key":"todos","group":"Wbudowane","insert":"/todos ","desc":"Pokazuje listę zadań."},
|
|
{"key":"upgrade","group":"Wbudowane","insert":"/upgrade ","desc":"Zmienia plan."},
|
|
{"key":"usage","group":"Wbudowane","insert":"/usage ","desc":"Pokazuje limity użycia."},
|
|
{"key":"vim","group":"Wbudowane","insert":"/vim ","desc":"Przełącza tryb vim."},
|
|
{"key":"workflows","group":"Wbudowane","insert":"/workflows ","desc":"Pokazuje przebieg workflow."},
|
|
{"key":"a","group":"Projekt","insert":"/a ","desc":"Komenda a"},
|
|
{"key":"s","group":"Projekt","insert":"/s ","desc":"Opis inna"},
|
|
{"key":"handoff","group":"Użytkownik","insert":"/handoff ","desc":"Przekazanie"},
|
|
{"key":"sp:brainstorming","group":"Pluginy","insert":"/sp:brainstorming ","desc":"Opis brainstorming"},
|
|
];
|
|
|
|
test("the / menu of Claude Code stays as it was", async () => {
|
|
const { exec, readText } = ccMachine(CC_FILES);
|
|
const global = await globalCommands(HOME, exec, readText, { sources: CC });
|
|
const items = await commands("/proj", exec, { profile: resolveProfile([], "claude-code"), global });
|
|
assert.deepEqual(items.map(ccRow), EXPECTED_CC);
|
|
});
|
|
|
|
test("commands: no profile gives only the history and the snippets, and no exec", async () => {
|
|
let calls = 0;
|
|
const exec = async () => {
|
|
calls += 1;
|
|
return { code: 0, stdout: "", stderr: "" };
|
|
};
|
|
const h = { key: "clear", desc: "", group: GROUP_HISTORY, insert: "/clear " };
|
|
assert.deepEqual(await commands("/x", exec, { profile: null, history: [h] }), [h]);
|
|
assert.equal(calls, 0);
|
|
});
|
|
|
|
test("commands: a profile project source with a prefix", async () => {
|
|
const profile = {
|
|
id: "kiro",
|
|
match: ["kiro-cli"],
|
|
builtins: [],
|
|
sources: [{ scope: "project", path: ".kiro/prompts", pattern: "*.md", prefix: "@" }],
|
|
};
|
|
const { exec } = ccMachine({ ".kiro/prompts/review.md": "---\ndescription: R\n---\n" });
|
|
const items = await commands("/x", exec, { profile });
|
|
assert.deepEqual(items, [
|
|
{ key: "review", desc: "R", group: "Projekt", insert: "@review " },
|
|
]);
|
|
});
|
|
|
|
test("commands: a project source path never reaches the shell as a script", async () => {
|
|
const seen = [];
|
|
const exec = async (command, args) => {
|
|
seen.push([command, args]);
|
|
return { code: 0, stdout: "", stderr: "" };
|
|
};
|
|
const profile = {
|
|
id: "x",
|
|
match: ["x"],
|
|
builtins: [],
|
|
sources: [{ scope: "project", path: ".a b/Zażółć", pattern: "*.md", prefix: "/" }],
|
|
};
|
|
await commands("/x", exec, { profile });
|
|
assert.equal(seen.length, 1);
|
|
assert.ok(!seen[0][1][1].includes("Zażółć"));
|
|
assert.ok(seen[0][1].includes(".a b/Zażółć"));
|
|
});
|
|
|
|
test("globalCommands: no sources gives [] and no exec", async () => {
|
|
let calls = 0;
|
|
const exec = async () => {
|
|
calls += 1;
|
|
return { code: 0, stdout: "", stderr: "" };
|
|
};
|
|
assert.deepEqual(await globalCommands(HOME, exec, async () => null, { sources: [] }), []);
|
|
assert.deepEqual(await globalCommands(HOME, exec, async () => null), []);
|
|
assert.equal(calls, 0);
|
|
});
|
|
|
|
test("globalCommands: a home source gives the Użytkownik group with its prefix", async () => {
|
|
const { exec, readText } = machine({ [`${HOME}/.kiro/prompts/plan.md`]: "---\ndescription: P\n---\n" });
|
|
const sources = [{ scope: "home", path: ".kiro/prompts", pattern: "*.md", prefix: "@" }];
|
|
const items = await globalCommands(HOME, exec, readText, { sources });
|
|
assert.deepEqual(items, [{ key: "plan", desc: "P", group: GROUP_USER, insert: "@plan " }]);
|
|
});
|
|
|
|
test("globalCommands: a project source is not read from home", async () => {
|
|
const { exec, readText } = machine({ [`${HOME}/.kiro/prompts/plan.md`]: "x" });
|
|
const sources = [{ scope: "project", path: ".kiro/prompts", pattern: "*.md", prefix: "/" }];
|
|
assert.deepEqual(await globalCommands(HOME, exec, readText, { sources }), []);
|
|
});
|
|
|
|
test("historyCommands: commands of this agent, newest first, no paths", () => {
|
|
const e = (text, sentAt, agentName = "claude-code") => ({ text, sentAt, agentName });
|
|
const history = [
|
|
e("/clear", 1),
|
|
e(" /superpowers:brainstorming x", 5),
|
|
e("/c/Users/x", 6),
|
|
e("/ cos", 7),
|
|
e("/", 8),
|
|
e("hej /clear", 9),
|
|
e("/other", 10, "codex"),
|
|
];
|
|
const items = historyCommands(history, "Claude-Code");
|
|
assert.deepEqual(items.map((i) => i.key), ["superpowers:brainstorming", "clear"]);
|
|
assert.ok(items.every((i) => i.group === "Z historii" && i.desc === ""));
|
|
assert.equal(items[0].insert, "/superpowers:brainstorming ");
|
|
});
|
|
|
|
test("commands: a history command that is a builtin shows once, as Wbudowane", async () => {
|
|
const exec = async () => ({ code: 0, stdout: "", stderr: "" });
|
|
const items = await commands("/x", exec, {
|
|
profile: resolveProfile([], "codex"),
|
|
history: historyCommands([{ text: "/model", sentAt: 1, agentName: "codex" }], "codex"),
|
|
});
|
|
const model = items.filter((i) => i.key === "model");
|
|
assert.equal(model.length, 1);
|
|
assert.equal(model[0].group, "Wbudowane");
|
|
});
|
|
|
|
test("GROUPS has Z historii right after Pluginy", () => {
|
|
assert.equal(GROUPS[GROUPS.indexOf("Pluginy") + 1], "Z historii");
|
|
});
|
|
|
|
test("menuNotes: an unknown agent names the key, but only once the file was read", () => {
|
|
const loaded = menuNotes({ profile: null, agent: "kiro-cli", profilesLoaded: true, problem: null });
|
|
assert.equal(loaded.length, 1);
|
|
assert.ok(loaded[0].includes("`kiro-cli`"));
|
|
assert.ok(loaded[0].includes("composer-agents.json"));
|
|
assert.deepEqual(menuNotes({ profile: null, agent: "kiro-cli", profilesLoaded: false, problem: null }), []);
|
|
});
|
|
|
|
test("menuNotes: a problem with the file is one row", () => {
|
|
assert.deepEqual(
|
|
menuNotes({ profile: CC_PROFILE, agent: "claude", profilesLoaded: true, problem: "nieczytelny JSON" }),
|
|
["`composer-agents.json`: nieczytelny JSON"],
|
|
);
|
|
});
|
|
|
|
test("menuNotes: unknown agent first, then the problem", () => {
|
|
const notes = menuNotes({ profile: null, agent: "kiro-cli", profilesLoaded: true, problem: "brak listy agents" });
|
|
assert.equal(notes.length, 2);
|
|
assert.ok(notes[0].startsWith("Nieznany agent"));
|
|
assert.equal(notes[1], "`composer-agents.json`: brak listy agents");
|
|
});
|