summer-engine 1.4.0 → 2.0.0

package/dist/commands/scene.js

@@ -0,0 +1,290 @@
+import { Command } from "commander";
+import { readFile } from "fs/promises";
+import { join } from "path";
+import { withEngineClient } from "../lib/with-engine.js";
+import { outputResult, outputError, parseValue, readJsonArg, isJsonMode, } from "../lib/format.js";
+async function readMainSceneFromProject(projectPath) {
+    if (!projectPath)
+        return null;
+    try {
+        const text = await readFile(join(projectPath, "project.godot"), "utf-8");
+        const match = text.match(/run\/main_scene="([^"]+)"/);
+        return match?.[1] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export const sceneCommand = new Command("scene").description("Scene editing commands (requires running engine)");
+// --- Tier 1 ---
+sceneCommand
+    .command("tree")
+    .description("Get the full scene tree of the currently open scene")
+    .action(async (_opts, cmd) => {
+    const fmt = isJsonMode(cmd);
+    try {
+        const result = await withEngineClient((c) => c.getSceneState());
+        outputResult(result, fmt);
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err), fmt);
+    }
+});
+sceneCommand
+    .command("open <path>")
+    .description("Open a scene file in the editor (e.g. res://main.tscn)")
+    .action(async (path, _opts, cmd) => {
+    const fmt = isJsonMode(cmd);
+    try {
+        const result = await withEngineClient((c) => c.executeOps([{ op: "OpenScene", path }]));
+        outputResult(result, fmt);
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err), fmt);
+    }
+});
+sceneCommand
+    .command("add <parent> <type> <name>")
+    .description("Add a node to the scene tree (e.g. summer scene add ./World MeshInstance3D Floor)")
+    .action(async (parent, type, name, _opts, cmd) => {
+    const fmt = isJsonMode(cmd);
+    try {
+        const result = await withEngineClient((c) => c.executeOps([{ op: "AddNode", parent, type, name }]));
+        outputResult(result, fmt);
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err), fmt);
+    }
+});
+sceneCommand
+    .command("prop <path> <key> <value>")
+    .description('Set a property on a node (e.g. summer scene prop ./Player position "Vector3(0,5,0)")')
+    .action(async (path, key, value, _opts, cmd) => {
+    const fmt = isJsonMode(cmd);
+    try {
+        const result = await withEngineClient((c) => c.executeOps([{ op: "SetProp", path, key, value: parseValue(value) }]));
+        outputResult(result, fmt);
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err), fmt);
+    }
+});
+sceneCommand
+    .command("save [path]")
+    .description("Save the current scene (optionally save-as to a new path)")
+    .action(async (path, _opts, cmd) => {
+    const fmt = isJsonMode(cmd);
+    try {
+        const op = { op: "SaveScene" };
+        if (path)
+            op.path = path;
+        const result = await withEngineClient((c) => c.executeOps([op]));
+        outputResult(result, fmt);
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err), fmt);
+    }
+});
+sceneCommand
+    .command("inspect <path>")
+    .description("Get all editable properties of a node (e.g. summer scene inspect Player)")
+    .action(async (path, _opts, cmd) => {
+    const fmt = isJsonMode(cmd);
+    try {
+        const result = await withEngineClient((c) => c.inspectNode(path));
+        outputResult(result, fmt);
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err), fmt);
+    }
+});
+sceneCommand
+    .command("batch <json>")
+    .description('Execute multiple ops in one undo step. Pass JSON array or "-" for stdin')
+    .action(async (jsonArg, _opts, cmd) => {
+    const fmt = isJsonMode(cmd);
+    try {
+        const ops = (await readJsonArg(jsonArg));
+        const result = await withEngineClient((c) => c.executeOps(ops, { groupUndo: true }));
+        outputResult(result, fmt);
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err), fmt);
+    }
+});
+// --- Tier 2 ---
+sceneCommand
+    .command("remove <path>")
+    .description("Remove a node and all its children from the scene tree")
+    .action(async (path, _opts, cmd) => {
+    const fmt = isJsonMode(cmd);
+    try {
+        const result = await withEngineClient((c) => c.executeOps([{ op: "RemoveNode", path }]));
+        outputResult(result, fmt);
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err), fmt);
+    }
+});
+sceneCommand
+    .command("rprop <nodePath> <resourceProperty> <subProperty> <value>")
+    .description("Set a nested resource property (e.g. summer scene rprop ./Player/Col shape size \"Vector3(1,2,1)\")")
+    .action(async (nodePath, resourceProperty, subProperty, value, _opts, cmd) => {
+    const fmt = isJsonMode(cmd);
+    try {
+        const result = await withEngineClient((c) => c.executeOps([
+            {
+                op: "SetResourceProperty",
+                nodePath,
+                resourceProperty,
+                subProperty,
+                value: parseValue(value),
+            },
+        ]));
+        outputResult(result, fmt);
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err), fmt);
+    }
+});
+sceneCommand
+    .command("instantiate <parent> <scene>")
+    .description("Add an existing scene/model as a child (e.g. summer scene instantiate ./World res://player.tscn)")
+    .option("--name <name>", "Override the instance name")
+    .action(async (parent, scene, opts, cmd) => {
+    const fmt = isJsonMode(cmd);
+    try {
+        const op = {
+            op: "InstantiateScene",
+            parent,
+            scene,
+        };
+        if (opts.name)
+            op.name = opts.name;
+        const result = await withEngineClient((c) => c.executeOps([op]));
+        outputResult(result, fmt);
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err), fmt);
+    }
+});
+sceneCommand
+    .command("create <path>")
+    .description("Create a new empty scene file")
+    .option("--root-name <name>", "Root node name", "Main")
+    .option("--yes", "Skip safety confirmation")
+    .action(async (path, opts, cmd) => {
+    const fmt = isJsonMode(cmd);
+    if (!opts.yes) {
+        outputError("Scene creation uses a temporary mutation strategy. Pass --yes to confirm.", fmt);
+    }
+    try {
+        const result = await withEngineClient(async (client) => {
+            const health = (await client.health());
+            const currentScene = typeof health.scene === "string" && health.scene.length > 0
+                ? health.scene
+                : null;
+            const projectPath = typeof health.project_path === "string"
+                ? health.project_path
+                : undefined;
+            const mainScene = await readMainSceneFromProject(projectPath);
+            const templateScene = currentScene || mainScene;
+            if (!templateScene) {
+                throw new Error("No scene open and could not resolve main scene. Run `summer project context` first.");
+            }
+            await client.executeOps([{ op: "OpenScene", path: templateScene }]);
+            const tree = (await client.getSceneState());
+            const children = tree.data?.children ?? tree.children ?? [];
+            const removeOps = children
+                .map((c) => c.path)
+                .filter((p) => typeof p === "string" && p.length > 0)
+                .map((p) => ({ op: "RemoveNode", path: `./${p}` }));
+            if (removeOps.length > 0) {
+                await client.executeOps(removeOps, { groupUndo: true });
+            }
+            await client.executeOps([
+                { op: "SetProp", path: ".", key: "name", value: opts.rootName },
+            ]);
+            await client.executeOps([{ op: "SaveScene", path }]);
+            if (currentScene && currentScene !== path) {
+                await client.executeOps([{ op: "OpenScene", path: currentScene }]);
+            }
+            return {
+                ok: true,
+                created: path,
+                rootName: opts.rootName,
+                templateScene,
+                restoredScene: currentScene,
+            };
+        });
+        outputResult(result, fmt);
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err), fmt);
+    }
+});
+sceneCommand
+    .command("replace <path>")
+    .description("Replace a node with a different type or scene")
+    .option("--type <type>", "New node type (e.g. RigidBody3D)")
+    .option("--scene <scene>", "Scene to replace with (e.g. res://enemies/boss.tscn)")
+    .action(async (path, opts, cmd) => {
+    const fmt = isJsonMode(cmd);
+    try {
+        const op = { op: "ReplaceNode", path };
+        if (opts.type)
+            op.type = opts.type;
+        if (opts.scene)
+            op.scene = opts.scene;
+        const result = await withEngineClient((c) => c.executeOps([op]));
+        outputResult(result, fmt);
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err), fmt);
+    }
+});
+sceneCommand
+    .command("signal <emitter> <signal> <receiver> <method>")
+    .description("Connect a signal between two nodes (e.g. summer scene signal ./HitArea body_entered ./Player _on_hit)")
+    .action(async (emitter, signal, receiver, method, _opts, cmd) => {
+    const fmt = isJsonMode(cmd);
+    try {
+        const result = await withEngineClient((c) => c.executeOps([
+            { op: "ConnectSignal", emitter, signal, receiver, method },
+        ]));
+        outputResult(result, fmt);
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err), fmt);
+    }
+});
+sceneCommand
+    .command("select <nodePath>")
+    .description("Select a node in the editor inspector")
+    .option("--scene <scenePath>", "Open this scene first, then select")
+    .action(async (nodePath, opts, cmd) => {
+    const fmt = isJsonMode(cmd);
+    try {
+        const op = { op: "SelectNode", nodePath };
+        if (opts.scene)
+            op.scenePath = opts.scene;
+        const result = await withEngineClient((c) => c.executeOps([op]));
+        outputResult(result, fmt);
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err), fmt);
+    }
+});
+sceneCommand
+    .command("inspect-resource <path>")
+    .description("Get all properties of a resource (material, mesh, shape, etc.)")
+    .action(async (path, _opts, cmd) => {
+    const fmt = isJsonMode(cmd);
+    try {
+        const result = await withEngineClient((c) => c.inspectResource(path));
+        outputResult(result, fmt);
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err), fmt);
+    }
+});

package/dist/lib/banner.js

@@ -84,10 +84,10 @@ export function getWelcome(version) {
     ];
     const footerLines = [
         pad("", 69),
-        pad(`  ${sunC2}summer-engine-cli${reset} · ${dim}local${reset}`, 69),
+        pad(`  ${sunC2}summer${reset} · ${dim}local${reset}`, 69),
         pad(`  ${dim}Docs: https://summerengine.com/docs/mcp${reset}`, 69)
     ];
-    const title = ` Summer Engine CLI v${version} `;
+    const title = ` Summer v${version} `;
     const titleLen = stripAnsi(title).length;
     const totalDashes = 69 - titleLen;
     const leftDashes = Math.floor(totalDashes / 2);

package/dist/lib/log-filters.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Post-processors for engine log/diagnostic payloads before they are returned
+ * to the AI model. The engine API stays lossless; the AI-facing surface
+ * trims, dedupes, and prioritizes.
+ *
+ * Two passes:
+ *  - dedupe(): collapse consecutive identical messages into one with a
+ *    `(×N)` count suffix so a 200-frame `null check` flood reads as one line.
+ *  - errorsOnly(): drop info/std lines, keep errors and warnings.
+ */
+export type LogEntry = {
+    message?: string;
+    text?: string;
+    type?: string;
+    severity?: string;
+    level?: string;
+    timestamp?: string;
+    [k: string]: unknown;
+};
+export interface FilterOptions {
+    /** Drop everything that isn't an error or warning. Default: false. */
+    errorsOnly?: boolean;
+    /** Drop everything that isn't an error. Default: false. */
+    errorsOnlyStrict?: boolean;
+    /** Hard cap on returned entries after dedupe. Default: 100. */
+    maxEntries?: number;
+    /** Skip dedupe — return everything as-is. Default: false. */
+    noDedupe?: boolean;
+}
+export interface FilterSummary {
+    totalIn: number;
+    totalOut: number;
+    duplicatesCollapsed: number;
+    droppedByLevel: number;
+    truncated: number;
+}
+export interface FilterResult<T extends LogEntry = LogEntry> {
+    entries: T[];
+    summary: FilterSummary;
+}
+export declare function filterAndDedupe<T extends LogEntry>(entries: T[], opts?: FilterOptions): FilterResult<T>;
+/**
+ * Walks a parsed engine response and applies filterAndDedupe to the first
+ * recognized log-bearing array. Mutates a clone — the input is not modified.
+ *
+ * Returns a tuple of [shapedResult, summary] where shapedResult is the same
+ * shape as input but with the array replaced and a `_filter` summary
+ * appended at the same level so the model can see what was hidden.
+ */
+export declare function shapeEngineLogResponse(raw: unknown, opts?: FilterOptions): {
+    result: unknown;
+    summary: FilterSummary | null;
+};

package/dist/lib/log-filters.js

@@ -0,0 +1,130 @@
+const ERROR_TYPES = new Set(["error", "fatal", "critical"]);
+const WARNING_TYPES = new Set(["warning", "warn"]);
+const NOISE_TYPES = new Set(["info", "debug", "std", "stdout", "trace", "verbose"]);
+function entryKey(e) {
+    // Identical message + same type counts as a duplicate.
+    // Timestamps differ by frame, so they're excluded from the key.
+    const msg = (e.message ?? e.text ?? "").trim();
+    const type = (e.type ?? e.severity ?? e.level ?? "").toLowerCase();
+    return `${type}::${msg}`;
+}
+function entryLevel(e) {
+    const t = (e.type ?? e.severity ?? e.level ?? "").toLowerCase();
+    if (ERROR_TYPES.has(t))
+        return "error";
+    if (WARNING_TYPES.has(t))
+        return "warning";
+    if (NOISE_TYPES.has(t))
+        return "noise";
+    return "other";
+}
+export function filterAndDedupe(entries, opts = {}) {
+    const { errorsOnly = false, errorsOnlyStrict = false, maxEntries = 100, noDedupe = false } = opts;
+    const summary = {
+        totalIn: entries.length,
+        totalOut: 0,
+        duplicatesCollapsed: 0,
+        droppedByLevel: 0,
+        truncated: 0,
+    };
+    // Pass 1: level filter
+    let kept = entries;
+    if (errorsOnlyStrict || errorsOnly) {
+        kept = entries.filter((e) => {
+            const level = entryLevel(e);
+            if (errorsOnlyStrict)
+                return level === "error";
+            return level === "error" || level === "warning";
+        });
+        summary.droppedByLevel = entries.length - kept.length;
+    }
+    // Pass 2: dedupe consecutive identical entries
+    let deduped;
+    if (noDedupe) {
+        deduped = kept;
+    }
+    else {
+        deduped = [];
+        let lastKey = null;
+        let lastIdx = -1;
+        let runCount = 0;
+        for (const e of kept) {
+            const key = entryKey(e);
+            if (key === lastKey && lastIdx >= 0) {
+                runCount += 1;
+                const tagged = { ...deduped[lastIdx] };
+                tagged.duplicate_count = runCount;
+                const baseMsg = (tagged.message ?? tagged.text ?? "");
+                const stripped = baseMsg.replace(/\s*\(×\d+\)\s*$/, "");
+                if (tagged.message !== undefined)
+                    tagged.message = `${stripped} (×${runCount})`;
+                else if (tagged.text !== undefined)
+                    tagged.text = `${stripped} (×${runCount})`;
+                deduped[lastIdx] = tagged;
+                summary.duplicatesCollapsed += 1;
+            }
+            else {
+                deduped.push(e);
+                lastKey = key;
+                lastIdx = deduped.length - 1;
+                runCount = 1;
+            }
+        }
+    }
+    // Pass 3: truncate
+    let final = deduped;
+    if (deduped.length > maxEntries) {
+        final = deduped.slice(0, maxEntries);
+        summary.truncated = deduped.length - maxEntries;
+    }
+    summary.totalOut = final.length;
+    return { entries: final, summary };
+}
+const ENTRY_KEYS = ["messages", "errors", "entries", "items", "lines", "output"];
+/**
+ * Walks a parsed engine response and applies filterAndDedupe to the first
+ * recognized log-bearing array. Mutates a clone — the input is not modified.
+ *
+ * Returns a tuple of [shapedResult, summary] where shapedResult is the same
+ * shape as input but with the array replaced and a `_filter` summary
+ * appended at the same level so the model can see what was hidden.
+ */
+export function shapeEngineLogResponse(raw, opts = {}) {
+    if (!raw || typeof raw !== "object")
+        return { result: raw, summary: null };
+    const cloned = JSON.parse(JSON.stringify(raw));
+    const summary = applyToFirstArray(cloned, opts);
+    return { result: cloned, summary };
+}
+function applyToFirstArray(node, opts) {
+    if (!node || typeof node !== "object")
+        return null;
+    if (Array.isArray(node)) {
+        for (const item of node) {
+            if (item && typeof item === "object") {
+                const inner = applyToFirstArray(item, opts);
+                if (inner)
+                    return inner;
+            }
+        }
+        return null;
+    }
+    const obj = node;
+    for (const key of ENTRY_KEYS) {
+        const arr = obj[key];
+        if (Array.isArray(arr) && arr.length > 0 && typeof arr[0] === "object") {
+            const { entries, summary } = filterAndDedupe(arr, opts);
+            obj[key] = entries;
+            obj["_filter"] = summary;
+            return summary;
+        }
+    }
+    for (const v of Object.values(obj)) {
+        if (v && typeof v === "object") {
+            const inner = applyToFirstArray(v, opts);
+            if (inner)
+                return inner;
+        }
+    }
+    return null;
+}

package/dist/lib/plugin-manifests.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/plugin-manifests.test.js

@@ -0,0 +1,134 @@
+/**
+ * Validates that every agent plugin manifest references real, on-disk skills,
+ * and that every skill claimed HAVE in catalog.yaml actually exists.
+ *
+ * Catches broken-path bugs before they ship. Add a manifest, add a path here.
+ */
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const repoRoot = join(__dirname, "..", "..");
+const MANIFESTS = [
+    {
+        name: ".claude-plugin/plugin.json",
+        path: join(repoRoot, ".claude-plugin", "plugin.json"),
+        skillsField: [],
+    },
+    {
+        name: ".cursor-plugin/plugin.json",
+        path: join(repoRoot, ".cursor-plugin", "plugin.json"),
+        skillsField: [],
+    },
+    {
+        name: ".codex-plugin/plugin.json",
+        path: join(repoRoot, ".codex-plugin", "plugin.json"),
+        skillsField: [],
+    },
+];
+function loadSkillsField(manifestPath) {
+    const raw = readFileSync(manifestPath, "utf-8");
+    const json = JSON.parse(raw);
+    if (json.skills === undefined) {
+        throw new Error(`${manifestPath}: missing "skills" field`);
+    }
+    return json.skills;
+}
+function listSkillDirs(skillsRoot) {
+    const entries = readdirSync(skillsRoot);
+    const out = [];
+    for (const cat of entries) {
+        const catPath = join(skillsRoot, cat);
+        if (!statSync(catPath).isDirectory())
+            continue;
+        if (cat === "_shared" || cat === "_tests")
+            continue;
+        for (const skill of readdirSync(catPath)) {
+            const skillPath = join(catPath, skill);
+            if (!statSync(skillPath).isDirectory())
+                continue;
+            if (existsSync(join(skillPath, "SKILL.md"))) {
+                out.push(`./skills/${cat}/${skill}/`);
+            }
+        }
+    }
+    return out;
+}
+describe("agent plugin manifests", () => {
+    for (const m of MANIFESTS) {
+        describe(m.name, () => {
+            it("exists and parses as JSON", () => {
+                expect(existsSync(m.path), `${m.name} not found`).toBe(true);
+                m.skillsField = loadSkillsField(m.path);
+            });
+            it("every referenced skill path resolves to a SKILL.md on disk", () => {
+                const skills = m.skillsField;
+                if (typeof skills === "string") {
+                    // Directory pointer mode (e.g. "./skills/")
+                    const dir = join(repoRoot, skills);
+                    expect(existsSync(dir), `${m.name}: skills dir ${skills} missing`).toBe(true);
+                    return;
+                }
+                const broken = [];
+                for (const rel of skills) {
+                    const skillMd = join(repoRoot, rel, "SKILL.md");
+                    if (!existsSync(skillMd))
+                        broken.push(rel);
+                }
+                expect(broken, `${m.name} references missing skills:\n${broken.join("\n")}`).toEqual([]);
+            });
+            it("does not duplicate skill paths", () => {
+                const skills = m.skillsField;
+                if (typeof skills === "string")
+                    return;
+                const seen = new Set();
+                const dupes = [];
+                for (const rel of skills) {
+                    if (seen.has(rel))
+                        dupes.push(rel);
+                    seen.add(rel);
+                }
+                expect(dupes, `${m.name} duplicates: ${dupes.join(", ")}`).toEqual([]);
+            });
+        });
+    }
+    describe("skills directory <-> manifest coverage", () => {
+        it("every on-disk skill is listed in .claude-plugin/plugin.json", () => {
+            const onDisk = listSkillDirs(join(repoRoot, "skills"));
+            const claudeManifest = JSON.parse(readFileSync(join(repoRoot, ".claude-plugin", "plugin.json"), "utf-8"));
+            const listed = new Set(claudeManifest.skills);
+            const orphans = onDisk.filter((p) => !listed.has(p));
+            expect(orphans, `On-disk skills missing from .claude-plugin/plugin.json (add or move under skills/_shared|_tests):\n${orphans.join("\n")}`).toEqual([]);
+        });
+    });
+});
+describe("skill SKILL.md frontmatter", () => {
+    it("every shipped SKILL.md has name and Use-when-style description", () => {
+        const skillsRoot = join(repoRoot, "skills");
+        const skillDirs = listSkillDirs(skillsRoot);
+        const failures = [];
+        for (const rel of skillDirs) {
+            const file = join(repoRoot, rel, "SKILL.md");
+            const text = readFileSync(file, "utf-8");
+            const match = text.match(/^---\s*\n([\s\S]+?)\n---/);
+            if (!match) {
+                failures.push(`${rel}: no frontmatter`);
+                continue;
+            }
+            const fm = match[1];
+            const nameMatch = fm.match(/^name:\s*(.+)$/m);
+            const descMatch = fm.match(/^description:\s*(.+)$/m);
+            if (!nameMatch || !nameMatch[1].trim())
+                failures.push(`${rel}: missing name`);
+            if (!descMatch || !descMatch[1].trim())
+                failures.push(`${rel}: missing description`);
+            const desc = descMatch?.[1] ?? "";
+            // Auto-trigger discipline: description must contain "Use when"
+            if (desc && !/\bUse when\b/i.test(desc)) {
+                failures.push(`${rel}: description must contain "Use when ..." (got: "${desc.slice(0, 80)}...")`);
+            }
+        }
+        expect(failures, `Skill frontmatter problems:\n${failures.join("\n")}`).toEqual([]);
+    });
+});

package/dist/lib/remote-templates.d.ts

@@ -0,0 +1,25 @@
+export interface RemoteTemplate {
+    /** Slug used by `summer create <slug>`. The `template-` prefix is stripped. */
+    slug: string;
+    /** Full GitHub repo name including the `template-` prefix. */
+    repo: string;
+    description: string;
+    /** Default branch — used when cloning. */
+    branch: string;
+    url: string;
+    cloneUrl: string;
+    stars: number;
+    updatedAt: string;
+}
+export declare function fetchRemoteTemplates(opts?: {
+    force?: boolean;
+}): Promise<RemoteTemplate[]>;
+export interface CloneOptions {
+    /** Where to put the project. Must not already exist. */
+    targetDir: string;
+    /** If true, drop the .git directory after clone so the user starts with a clean history. */
+    detach?: boolean;
+}
+export declare function cloneTemplate(template: RemoteTemplate, opts: CloneOptions): void;
+/** Quick match: exact slug, then prefix, then substring. Returns null if ambiguous or none. */
+export declare function matchTemplate(query: string, templates: RemoteTemplate[]): RemoteTemplate | null;