@lapis-notes/ai 0.1.0

package/dist/commands/groups.d.ts

@@ -0,0 +1,16 @@
+import type { EffectiveSlashCommand, SlashCommandSource } from "./types";
+export type ComposerSlashItem = {
+    id: string;
+    label: string;
+    value: string;
+    description: string;
+    source: SlashCommandSource;
+    submitOnSelect: boolean;
+};
+export type SlashCommandGroup = "app" | "actions" | "skills" | "agent";
+export declare function slashCommandGroup(command: EffectiveSlashCommand): SlashCommandGroup;
+export declare function groupLabel(group: SlashCommandGroup, agentLabel?: string): string;
+export declare function groupSlashCommands(commands: readonly EffectiveSlashCommand[]): Record<SlashCommandGroup, EffectiveSlashCommand[]>;
+export declare function formatSlashHelp(commands: readonly EffectiveSlashCommand[], agentLabel?: string): string;
+export declare function composerSlashItems(commands: readonly EffectiveSlashCommand[], agentLabel?: string): ComposerSlashItem[];
+export declare function filterComposerSlashItems(items: readonly ComposerSlashItem[], query: string): ComposerSlashItem[];

package/dist/commands/groups.js

@@ -0,0 +1,121 @@
+import { fuzzySearch } from "@lapis-notes/ui";
+const SLASH_SEARCH_KEYS = [
+    { name: "label", weight: 2 },
+    { name: "id", weight: 2 },
+];
+function normalizeSlashQuery(query) {
+    return query.trim().replace(/^\/+/u, "");
+}
+function commandNameFields(item) {
+    const label = item.label.replace(/^\/+/u, "");
+    const idTail = item.id.includes(":")
+        ? item.id.slice(item.id.lastIndexOf(":") + 1)
+        : item.id;
+    return [item.id, idTail, label, item.value.replace(/^\/+/u, "")];
+}
+function matchesCommandName(item, query) {
+    const needle = query.toLowerCase();
+    return commandNameFields(item).some((field) => field.toLowerCase().includes(needle));
+}
+const GROUP_LABEL = {
+    app: "App",
+    actions: "Actions",
+    skills: "Skills",
+    agent: "Current Agent",
+};
+const GROUP_ORDER = [
+    "app",
+    "actions",
+    "skills",
+    "agent",
+];
+export function slashCommandGroup(command) {
+    if (command.source === "extension" ||
+        command.source === "folder" ||
+        command.source === "vault" ||
+        command.source === "user") {
+        return "actions";
+    }
+    if (command.source === "skill")
+        return "skills";
+    if (command.source === "native-agent")
+        return "agent";
+    return "app";
+}
+export function groupLabel(group, agentLabel) {
+    if (group === "agent" && agentLabel)
+        return `Current Agent · ${agentLabel}`;
+    return GROUP_LABEL[group];
+}
+export function groupSlashCommands(commands) {
+    const groups = {
+        app: [],
+        actions: [],
+        skills: [],
+        agent: [],
+    };
+    for (const command of commands) {
+        groups[slashCommandGroup(command)].push(command);
+    }
+    return groups;
+}
+export function formatSlashHelp(commands, agentLabel) {
+    const grouped = groupSlashCommands(commands);
+    const sections = [];
+    for (const group of GROUP_ORDER) {
+        const items = grouped[group];
+        if (items.length === 0)
+            continue;
+        const lines = [groupLabel(group, agentLabel)];
+        for (const command of items) {
+            const name = command.source === "native-agent"
+                ? `/native ${command.name}`
+                : `/${command.name}`;
+            const hint = command.argumentHint ? ` ${command.argumentHint}` : "";
+            lines.push(`  ${name}${hint} — ${command.description}`);
+        }
+        sections.push(lines.join("\n"));
+    }
+    return sections.join("\n\n") || "No commands are available.";
+}
+export function composerSlashItems(commands, agentLabel) {
+    const grouped = groupSlashCommands(commands);
+    const items = [];
+    for (const group of GROUP_ORDER) {
+        const heading = groupLabel(group, agentLabel);
+        for (const command of grouped[group]) {
+            const native = command.source === "native-agent";
+            const label = native ? `/native ${command.name}` : `/${command.name}`;
+            items.push({
+                id: native ? `native:${command.name}` : command.name,
+                label,
+                value: label,
+                description: `${heading} · ${command.description}`,
+                source: command.source,
+                submitOnSelect: !command.argumentHint,
+            });
+        }
+    }
+    return items;
+}
+export function filterComposerSlashItems(items, query) {
+    const needle = normalizeSlashQuery(query);
+    if (!needle)
+        return [...items];
+    const options = {
+        keys: [...SLASH_SEARCH_KEYS, { name: "description", weight: 0.4 }],
+        minMatchCharLength: 1,
+    };
+    const matches = fuzzySearch([...items], needle, options);
+    const nameHits = [];
+    const descriptionHits = [];
+    for (const { item } of matches) {
+        if (matchesCommandName(item, needle)) {
+            nameHits.push(item);
+        }
+        else {
+            descriptionHits.push(item);
+        }
+    }
+    return [...nameHits, ...descriptionHits];
+}

package/dist/commands/inspect.d.ts

@@ -0,0 +1,18 @@
+export declare function formatScopeNotice(input: {
+    scopeDir: string;
+    launchNotePath?: string;
+    workspace?: string;
+    source?: "explicit" | "active-file" | "vault-root" | "conversation" | "folder";
+}): string;
+export declare function formatContextNotice(input: {
+    conversationId?: string;
+    scopeDir: string;
+    launchNotePath?: string;
+    workspace?: string;
+    agent: string;
+    model?: string;
+    tools: readonly string[];
+    skills: readonly string[];
+    folderInstructionPaths?: readonly string[];
+    truncated?: boolean;
+}): string;

package/dist/commands/inspect.js

@@ -0,0 +1,29 @@
+export function formatScopeNotice(input) {
+    const scope = input.scopeDir.trim() || "(vault root)";
+    const source = input.source ?? (input.scopeDir.trim() ? "folder" : "vault-root");
+    return [
+        `Scope: ${scope}`,
+        `Source: ${source}`,
+        `Started from: ${input.launchNotePath?.trim() || "(none)"}`,
+        `Workspace: ${input.workspace?.trim() || "(none)"}`,
+    ].join("\n");
+}
+export function formatContextNotice(input) {
+    const tools = input.tools.length > 0 ? input.tools.join(", ") : "(none)";
+    const skills = input.skills.length > 0 ? input.skills.join(", ") : "(none)";
+    const folders = input.folderInstructionPaths && input.folderInstructionPaths.length > 0
+        ? input.folderInstructionPaths.join(", ")
+        : "(none)";
+    return [
+        `Conversation: ${input.conversationId ?? "(none)"}`,
+        `Scope: ${input.scopeDir.trim() || "(vault root)"}`,
+        `Started from: ${input.launchNotePath?.trim() || "(none)"}`,
+        `Workspace: ${input.workspace?.trim() || "(none)"}`,
+        `Agent: ${input.agent}`,
+        `Model: ${input.model?.trim() || "(none)"}`,
+        `Available app tools: ${tools}`,
+        `Available skills: ${skills}`,
+        `Folder instructions: ${folders}`,
+        `Context status: ${input.truncated ? "Bootstrap truncated" : "No bootstrap truncation"}`,
+    ].join("\n");
+}

package/dist/commands/markdown.d.ts

@@ -0,0 +1,21 @@
+import type { AppSlashCommandDispatch } from "@lapis-notes/api/agent-skills";
+export declare class CommandParseError extends Error {
+    readonly path: string;
+    constructor(path: string, message: string);
+}
+export type CommandFileKind = "prompt" | "host" | "tool" | "skill";
+export interface ParsedCommandFile {
+    name: string;
+    description: string;
+    argumentHint?: string;
+    aliases?: string[];
+    kind: CommandFileKind;
+    tool?: string;
+    skill?: string;
+    template: string;
+}
+export declare function commandNameFromFilename(filename: string): string | undefined;
+export declare function parseCommandMarkdown(content: string, path: string, name: string): ParsedCommandFile;
+export declare function commandFileDispatch(parsed: ParsedCommandFile): AppSlashCommandDispatch;
+export declare function parseCommandArguments(raw: string): string[];
+export declare function interpolateCommandTemplate(template: string, rawArguments: string): string;

package/dist/commands/markdown.js

@@ -0,0 +1,117 @@
+import { parse as parseYaml } from "yaml";
+import { SLASH_COMMAND_NAME_PATTERN } from "@lapis-notes/api/agent-skills";
+const FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/u;
+const POSITIONAL = /\$([1-9]\d*)/gu;
+export class CommandParseError extends Error {
+    path;
+    constructor(path, message) {
+        super(message);
+        this.path = path;
+        this.name = "CommandParseError";
+    }
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function readStringList(value) {
+    if (typeof value === "string") {
+        return readStringList(value.split(","));
+    }
+    if (!Array.isArray(value))
+        return undefined;
+    const items = value
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    return items.length > 0 ? items : undefined;
+}
+export function commandNameFromFilename(filename) {
+    const name = filename.replace(/\.md$/u, "").trim();
+    return SLASH_COMMAND_NAME_PATTERN.test(name) ? name : undefined;
+}
+export function parseCommandMarkdown(content, path, name) {
+    if (!SLASH_COMMAND_NAME_PATTERN.test(name)) {
+        throw new CommandParseError(path, `Invalid command name: ${name}`);
+    }
+    const match = FRONTMATTER.exec(content);
+    const data = match ? parseYaml(match[1] ?? "") : {};
+    if (match && !isRecord(data)) {
+        throw new CommandParseError(path, "Command front-matter must be a mapping.");
+    }
+    const record = isRecord(data) ? data : {};
+    const kind = (readString(record.kind) ?? "prompt");
+    if (kind !== "prompt" &&
+        kind !== "host" &&
+        kind !== "tool" &&
+        kind !== "skill") {
+        throw new CommandParseError(path, `Unsupported command kind: ${kind}`);
+    }
+    const tool = readString(record.tool);
+    const skill = readString(record.skill);
+    if (kind === "tool" && !tool) {
+        throw new CommandParseError(path, "kind: tool requires tool");
+    }
+    if (kind === "skill" && !skill) {
+        throw new CommandParseError(path, "kind: skill requires skill");
+    }
+    const body = (match ? match[2] ?? "" : content).replace(/^\s+|\s+$/gu, "");
+    return {
+        name,
+        description: readString(record.description) ?? name,
+        argumentHint: readString(record.argumentHint) ?? readString(record["argument-hint"]),
+        aliases: readStringList(record.aliases),
+        kind,
+        tool,
+        skill,
+        template: body,
+    };
+}
+export function commandFileDispatch(parsed) {
+    if (parsed.kind === "tool" && parsed.tool) {
+        return { kind: "tool", tool: parsed.tool };
+    }
+    if (parsed.kind === "skill" && parsed.skill) {
+        return { kind: "skill", skill: parsed.skill };
+    }
+    if (parsed.kind === "host") {
+        return { kind: "host", execute: () => undefined };
+    }
+    return { kind: "prompt", template: parsed.template };
+}
+export function parseCommandArguments(raw) {
+    const items = [];
+    const pattern = /"([^"]*)"|'([^']*)'|(\S+)/gu;
+    let match = pattern.exec(raw);
+    while (match) {
+        items.push(match[1] ?? match[2] ?? match[3] ?? "");
+        match = pattern.exec(raw);
+    }
+    return items;
+}
+export function interpolateCommandTemplate(template, rawArguments) {
+    const body = template.replace(/^\s+|\s+$/gu, "");
+    const args = rawArguments.trim();
+    const hasNamed = body.includes("$ARGUMENTS") || body.includes("{{args}}");
+    const positionals = [...body.matchAll(POSITIONAL)].map((item) => Number(item[1]));
+    const hasPositional = positionals.length > 0;
+    let result = body
+        .replaceAll("$ARGUMENTS", args)
+        .replaceAll("{{args}}", args);
+    if (hasPositional) {
+        const parsed = parseCommandArguments(rawArguments);
+        const max = Math.max(...positionals);
+        result = result.replace(POSITIONAL, (_match, digits) => {
+            const index = Number(digits);
+            if (index === max)
+                return parsed.slice(index - 1).join(" ");
+            return parsed[index - 1] ?? "";
+        });
+    }
+    if (!hasNamed && !hasPositional && args) {
+        return `${result}\n\n${args}`;
+    }
+    return result;
+}

package/dist/commands/parser.d.ts

@@ -0,0 +1,4 @@
+import type { ParsedSlashCommand } from "./types";
+export declare function parseSlashCommand(input: string): ParsedSlashCommand | undefined;
+export declare function isLiteralSlashText(input: string): boolean;
+export declare function unescapeLiteralSlash(input: string): string;

package/dist/commands/parser.js

@@ -0,0 +1,24 @@
+const COMMAND_PATTERN = /^\/(?<name>[A-Za-z][A-Za-z0-9_-]{0,63})(?<sep>[:\s]|$)(?<args>.*)$/u;
+export function parseSlashCommand(input) {
+    const text = input.trimStart();
+    if (text.startsWith("//"))
+        return undefined;
+    if (!text.startsWith("/"))
+        return undefined;
+    const match = text.match(COMMAND_PATTERN);
+    if (!match?.groups?.name)
+        return undefined;
+    return {
+        name: match.groups.name.toLowerCase(),
+        rawArguments: (match.groups.args ?? "").trim(),
+        original: input,
+    };
+}
+export function isLiteralSlashText(input) {
+    return input.trimStart().startsWith("//");
+}
+export function unescapeLiteralSlash(input) {
+    const trimmedStart = input.match(/^\s*/u)?.[0] ?? "";
+    const rest = input.slice(trimmedStart.length);
+    return rest.startsWith("//") ? `${trimmedStart}${rest.slice(1)}` : input;
+}

package/dist/commands/reserved.d.ts

@@ -0,0 +1,4 @@
+import type { EffectiveSlashCommand } from "./types";
+export declare const RESERVED_SLASH_COMMANDS: EffectiveSlashCommand[];
+export declare function reservedSlashCommandNames(): Set<string>;
+export declare function reservedCommandMarkdown(command: EffectiveSlashCommand): string;

package/dist/commands/reserved.js

@@ -0,0 +1,107 @@
+export const RESERVED_SLASH_COMMANDS = [
+    {
+        name: "help",
+        description: "Show available commands grouped by App, Actions, Skills, and Current Agent.",
+        aliases: ["commands"],
+        source: "app",
+        dispatch: { kind: "host", execute: () => undefined },
+    },
+    {
+        name: "new",
+        description: "Start a new chat in the current scope.",
+        source: "app",
+        dispatch: { kind: "host", execute: () => undefined },
+    },
+    {
+        name: "agent",
+        description: "Show or switch the current agent.",
+        argumentHint: "[codex|cursor|native|fake]",
+        source: "app",
+        dispatch: { kind: "host", execute: () => undefined },
+    },
+    {
+        name: "model",
+        description: "Reserved. Change the model from the composer Model menu.",
+        argumentHint: "[name]",
+        source: "app",
+        dispatch: { kind: "host", execute: () => undefined },
+    },
+    {
+        name: "status",
+        description: "Show conversation, agent, model, scope, and executor context.",
+        source: "app",
+        dispatch: { kind: "host", execute: () => undefined },
+    },
+    {
+        name: "scope",
+        description: "Show the current folder scope, or start a new chat in a folder.",
+        argumentHint: "[folder]",
+        source: "app",
+        dispatch: { kind: "host", execute: () => undefined },
+    },
+    {
+        name: "context",
+        description: "Show the context the app is making available to the agent.",
+        source: "app",
+        dispatch: { kind: "host", execute: () => undefined },
+    },
+    {
+        name: "skills",
+        description: "List effective application skills.",
+        source: "app",
+        dispatch: { kind: "host", execute: () => undefined },
+    },
+    {
+        name: "tools",
+        description: "List effective application tools.",
+        source: "app",
+        dispatch: { kind: "host", execute: () => undefined },
+    },
+    {
+        name: "skill",
+        description: "Activate a skill by name.",
+        argumentHint: "<name> [arguments]",
+        source: "app",
+        dispatch: { kind: "host", execute: () => undefined },
+    },
+    {
+        name: "native",
+        description: "Forward a command to the current agent.",
+        argumentHint: "<command> [arguments]",
+        source: "app",
+        dispatch: { kind: "host", execute: () => undefined },
+    },
+    {
+        name: "cancel",
+        description: "Reserved. Use Stop in the composer to cancel the active run.",
+        source: "app",
+        dispatch: { kind: "host", execute: () => undefined },
+    },
+    {
+        name: "refresh",
+        description: "Refresh agent skills on a replacement binding.",
+        source: "app",
+        dispatch: { kind: "host", execute: () => undefined },
+    },
+];
+export function reservedSlashCommandNames() {
+    return new Set(RESERVED_SLASH_COMMANDS.flatMap((command) => [
+        command.name,
+        ...(command.aliases ?? []),
+    ]));
+}
+export function reservedCommandMarkdown(command) {
+    const lines = [
+        "---",
+        `description: ${JSON.stringify(command.description)}`,
+        "kind: host",
+    ];
+    if (command.argumentHint) {
+        lines.push(`argumentHint: ${JSON.stringify(command.argumentHint)}`);
+    }
+    if (command.aliases?.length) {
+        lines.push(`aliases: [${command.aliases.map((alias) => JSON.stringify(alias)).join(", ")}]`);
+    }
+    lines.push("---", "", `Reserved Lapis command \`/${command.name}\`. This file documents the host handler and is not sent as a prompt.`, "");
+    return lines.join("\n");
+}

package/dist/commands/router.d.ts

@@ -0,0 +1,17 @@
+import type { SkillRegistry } from "../skills/registry";
+import type { LoadedAppSkill, SkillDiscoveryContext } from "../skills/types";
+import { SlashCommandCatalog } from "./catalog";
+import type { CommandExecutionResult, CommandResolution, ParsedSlashCommand } from "./types";
+export declare class SlashCommandRouter {
+    #private;
+    readonly catalog: SlashCommandCatalog;
+    private readonly skills?;
+    constructor(catalog: SlashCommandCatalog, skills?: SkillRegistry | undefined);
+    parse(input: string): ParsedSlashCommand | undefined;
+    resolve(input: string, agentBindingId?: string): CommandResolution | undefined;
+    execute(resolution: CommandResolution, context: {
+        agentBindingId?: string;
+        discovery: SkillDiscoveryContext;
+        loadSkill?: (name: string) => LoadedAppSkill | undefined;
+    }): Promise<CommandExecutionResult>;
+}

package/dist/commands/router.js

@@ -0,0 +1,170 @@
+import { SlashCommandCatalog } from "./catalog";
+import { interpolateCommandTemplate } from "./markdown";
+import { isLiteralSlashText, parseSlashCommand, unescapeLiteralSlash, } from "./parser";
+export class SlashCommandRouter {
+    catalog;
+    skills;
+    constructor(catalog, skills) {
+        this.catalog = catalog;
+        this.skills = skills;
+    }
+    parse(input) {
+        return parseSlashCommand(input);
+    }
+    resolve(input, agentBindingId) {
+        if (isLiteralSlashText(input)) {
+            return { kind: "literal", text: unescapeLiteralSlash(input) };
+        }
+        const parsed = parseSlashCommand(input);
+        if (!parsed)
+            return undefined;
+        const command = this.catalog.get(parsed.name, agentBindingId);
+        if (!command) {
+            const suggestions = this.catalog
+                .list(agentBindingId)
+                .map((item) => item.name)
+                .filter((name) => name.startsWith(parsed.name.slice(0, 2)))
+                .slice(0, 5);
+            return { kind: "unknown", parsed, suggestions };
+        }
+        return { kind: "command", parsed, command };
+    }
+    async execute(resolution, context) {
+        if (resolution.kind === "literal") {
+            return { kind: "prompt", prompt: resolution.text };
+        }
+        if (resolution.kind === "unknown") {
+            const hint = resolution.suggestions.length > 0
+                ? ` Did you mean /${resolution.suggestions.join(", /")}?`
+                : "";
+            return {
+                kind: "error",
+                message: `Unknown command: /${resolution.parsed.name}.${hint}`,
+            };
+        }
+        const { parsed, command } = resolution;
+        return this.#dispatch(command, parsed, context);
+    }
+    async #dispatch(command, parsed, context) {
+        if (command.name === "skill") {
+            const [skillName, ...rest] = parsed.rawArguments.split(/\s+/u);
+            if (!skillName) {
+                return { kind: "error", message: "Usage: /skill <name> [arguments]" };
+            }
+            return this.#activateSkill(skillName, rest.join(" "), context);
+        }
+        if (command.name === "native") {
+            const [nativeName, ...rest] = parsed.rawArguments.split(/\s+/u);
+            if (!nativeName) {
+                return { kind: "error", message: "Usage: /native <command> [arguments]" };
+            }
+            const native = this.catalog.native(context.agentBindingId, nativeName);
+            if (!native) {
+                return {
+                    kind: "error",
+                    message: `Native command is unavailable: ${nativeName}`,
+                };
+            }
+            return {
+                kind: "native",
+                name: native.name,
+                arguments: rest.join(" "),
+            };
+        }
+        if (command.name === "new")
+            return { kind: "local", notice: "new" };
+        if (command.name === "help" || command.name === "commands") {
+            return { kind: "local", notice: "help" };
+        }
+        if (command.name === "skills")
+            return { kind: "local", notice: "skills" };
+        if (command.name === "tools")
+            return { kind: "local", notice: "tools" };
+        if (command.name === "refresh")
+            return { kind: "local", notice: "refresh" };
+        if (command.name === "scope") {
+            return {
+                kind: "local",
+                notice: "scope",
+                arguments: parsed.rawArguments,
+            };
+        }
+        if (command.name === "context" || command.name === "status") {
+            return { kind: "local", notice: "context" };
+        }
+        if (command.name === "model")
+            return { kind: "local", notice: "model" };
+        if (command.name === "cancel")
+            return { kind: "local", notice: "cancel" };
+        if (command.name === "agent") {
+            return {
+                kind: "local",
+                notice: "agent",
+                arguments: parsed.rawArguments,
+            };
+        }
+        const dispatch = command.dispatch;
+        if (dispatch.kind === "host") {
+            await dispatch.execute({
+                arguments: parsed.rawArguments,
+            });
+            return { kind: "local", notice: command.name };
+        }
+        if (dispatch.kind === "tool") {
+            return toolDispatch(dispatch.tool, parsed.rawArguments, command.name);
+        }
+        if (dispatch.kind === "skill") {
+            return this.#activateSkill(dispatch.skill, parsed.rawArguments, context);
+        }
+        if (dispatch.kind === "prompt") {
+            return {
+                kind: "prompt",
+                prompt: interpolateCommandTemplate(dispatch.template, parsed.rawArguments),
+            };
+        }
+        if (dispatch.kind === "native-agent") {
+            return {
+                kind: "native",
+                name: dispatch.nativeName,
+                arguments: parsed.rawArguments,
+            };
+        }
+        return { kind: "error", message: `Unsupported command: /${command.name}` };
+    }
+    async #activateSkill(name, args, context) {
+        const loaded = this.skills
+            ? await this.skills.resolve(name, context.discovery)
+            : undefined;
+        if (!loaded) {
+            return { kind: "error", message: `Unknown skill: ${name}` };
+        }
+        if (loaded.command.kind === "tool") {
+            return toolDispatch(loaded.command.tool, args, name);
+        }
+        const activation = this.skills
+            ? await this.skills.activate(name, context.discovery, "user", args)
+            : undefined;
+        if (!activation) {
+            return { kind: "error", message: `Unknown skill: ${name}` };
+        }
+        return { kind: "skill", activation };
+    }
+}
+function toolDispatch(tool, args, commandName) {
+    if (tool === "notes_search") {
+        const query = args.trim();
+        if (!query) {
+            return { kind: "error", message: `Usage: /${commandName} <query>` };
+        }
+        return { kind: "tool", tool, input: { query } };
+    }
+    return {
+        kind: "tool",
+        tool,
+        input: {
+            command: args,
+            commandName,
+            skillName: commandName,
+        },
+    };
+}

package/dist/commands/seed.d.ts

@@ -0,0 +1,4 @@
+import type { UserAgentsCommandStore } from "./user-agents";
+export declare function seedReservedCommands(store: UserAgentsCommandStore, options?: {
+    overwrite?: boolean;
+}): Promise<void>;

package/dist/commands/seed.js

@@ -0,0 +1,8 @@
+import { reservedCommandMarkdown, RESERVED_SLASH_COMMANDS, } from "./reserved";
+export async function seedReservedCommands(store, options = {}) {
+    for (const command of RESERVED_SLASH_COMMANDS) {
+        if (!options.overwrite && (await store.exists(command.name)))
+            continue;
+        await store.write(command.name, reservedCommandMarkdown(command));
+    }
+}