summer-engine 2.3.0 → 2.6.0

package/dist/lib/game-task-plan.js

@@ -0,0 +1,376 @@
+import { SKILL_REGISTRY } from "./skills-registry.js";
+export const GAME_TASK_MODES = [
+    "auto",
+    "new-game",
+    "feature",
+    "asset",
+    "debug",
+    "playtest",
+    "polish",
+    "ship",
+];
+export const GAME_TASK_TARGETS = [
+    "auto",
+    "2d",
+    "3d",
+    "ui",
+    "audio",
+    "animation",
+    "level",
+    "npc",
+    "multiplayer",
+];
+export const ASSET_POLICIES = [
+    "reuse-first",
+    "ask-before-paid-generation",
+    "no-paid-generation",
+    "generate-when-clearly-needed",
+];
+export const VERIFICATION_LEVELS = ["none", "fast", "full"];
+const SKILL_BY_NAME = new Map(SKILL_REGISTRY.map((skill) => [skill.name, skill]));
+function includesAny(text, words) {
+    return words.some((word) => text.includes(word));
+}
+function inferMode(goal, requested) {
+    if (requested !== "auto")
+        return requested;
+    const text = goal.toLowerCase();
+    const gameGenre = includesAny(text, [
+        "shooter",
+        "platformer",
+        "roguelike",
+        "rpg",
+        "racing",
+        "puzzle game",
+        "survival",
+        "tower defense",
+        "metroidvania",
+        "arena",
+    ]);
+    const buildVerb = /(^|\s)(make|build|create|start)\s/.test(text);
+    if (includesAny(text, ["crash", "bug", "error", "broken", "fix", "debug", "not working"]))
+        return "debug";
+    if (includesAny(text, ["export", "ship", "release", "build for", "deploy"]))
+        return "ship";
+    if (includesAny(text, ["playtest", "test the game", "feel", "tune"]))
+        return "playtest";
+    if (includesAny(text, ["asset", "model", "sprite", "texture", "sound", "music", "voice", "animation"]))
+        return "asset";
+    if (includesAny(text, ["new game", "start a game", "make a game", "prototype", "from scratch"]) || (buildVerb && gameGenre))
+        return "new-game";
+    if (includesAny(text, ["polish", "lighting", "performance", "juice", "ui pass"]))
+        return "polish";
+    return "feature";
+}
+function inferTarget(goal, requested) {
+    if (requested !== "auto")
+        return requested;
+    const text = goal.toLowerCase();
+    if (includesAny(text, ["3d", "model", "mesh", "glb", "character", "prop", "vehicle", "tree", "rock"]))
+        return "3d";
+    if (includesAny(text, ["2d", "sprite", "pixel", "portrait", "icon", "texture", "tileset", "skybox"]))
+        return "2d";
+    if (includesAny(text, ["sound", "sfx", "music", "audio", "voice", "dialogue", "ambient"]))
+        return "audio";
+    if (includesAny(text, ["animation", "animate", "idle", "walk", "run", "attack", "motion", "retarget"]))
+        return "animation";
+    if (includesAny(text, ["ui", "hud", "menu", "button", "inventory"]))
+        return "ui";
+    if (includesAny(text, ["level", "map", "dungeon", "arena", "room", "world"]))
+        return "level";
+    if (includesAny(text, ["npc", "enemy", "boss", "dialogue", "behavior"]))
+        return "npc";
+    if (includesAny(text, ["multiplayer", "network", "server", "host", "peer"]))
+        return "multiplayer";
+    return "general";
+}
+function addSkill(routes, name, why, weight) {
+    if (!SKILL_BY_NAME.has(name))
+        return;
+    const existing = routes.find((route) => route.name === name);
+    if (existing) {
+        if (weight > existing.weight) {
+            existing.weight = weight;
+            existing.why = why;
+        }
+        return;
+    }
+    routes.push({ name, why, weight });
+}
+function inferSkills(mode, target, goal) {
+    const text = goal.toLowerCase();
+    const routes = [];
+    const animationIntent = includesAny(text, [
+        "animated",
+        "animation",
+        "animate",
+        "idle",
+        "walk",
+        "run",
+        "jump",
+        "attack",
+        "motion",
+        "mocap",
+        "locomotion",
+        "animationtree",
+        "state machine",
+    ]);
+    const assetIntent = mode === "asset" ||
+        includesAny(text, [
+            "asset",
+            "model",
+            "mesh",
+            "glb",
+            "sprite",
+            "texture",
+            "sound",
+            "sfx",
+            "music",
+            "voice",
+            "animation clip",
+        ]);
+    addSkill(routes, "using-summer", "Baseline workflow for building through Summer CLI/MCP.", 100);
+    if (mode === "debug") {
+        addSkill(routes, "debug", "Primary runtime/script/diagnostics loop.", 300);
+        addSkill(routes, "investigating-bugs", "Systematic bug investigation workflow.", 220);
+    }
+    if (mode === "playtest") {
+        addSkill(routes, "play", "Run, observe, and report runtime state.", 260);
+        addSkill(routes, "playtesting-a-feature", "Feature-level playtest loop.", 220);
+        addSkill(routes, "debugging-game-feel", "Tune feel problems after runtime verification.", 160);
+    }
+    if (mode === "new-game") {
+        addSkill(routes, "new-project", "Create/open the project if needed.", 260);
+        addSkill(routes, "brainstorm-game", "Lock a small playable brief before building.", 240);
+        addSkill(routes, "make-game", "Build one narrow playable prototype end-to-end.", 300);
+    }
+    if (mode === "ship") {
+        addSkill(routes, "export-and-ship", "Export and release readiness workflow.", 280);
+        addSkill(routes, "tune-performance", "Performance pass before shipping.", 180);
+    }
+    if (mode === "polish") {
+        addSkill(routes, "art-direction", "Visual consistency and taste pass.", 200);
+        addSkill(routes, "3d-lighting", "Lighting/world environment pass for 3D scenes.", 190);
+        addSkill(routes, "game-feel", "Screen shake, hit-stop, juice, and responsiveness.", 180);
+        addSkill(routes, "tune-performance", "Frame budget and bottleneck pass.", 170);
+    }
+    if (assetIntent) {
+        addSkill(routes, "asset-strategy", "Choose reuse/import/generate before spending credits.", 260);
+    }
+    if (target === "3d" && assetIntent) {
+        if (includesAny(text, ["character", "player", "npc", "enemy", "boss", "humanoid", "rig"])) {
+            addSkill(routes, "character-model", "Humanoid T-pose, mesh, rig, and handoff to animation.", 300);
+        }
+        else if (includesAny(text, ["vehicle", "car", "ship", "spaceship", "mech", "tank", "bike"])) {
+            addSkill(routes, "vehicle-model", "Hard-surface vehicle generation and scene wiring.", 280);
+        }
+        else if (includesAny(text, ["tree", "rock", "mushroom", "foliage", "plant", "crystal"])) {
+            addSkill(routes, "organic-model", "Fast organic 3D asset generation and scatter guidance.", 270);
+        }
+        else if (includesAny(text, ["kit", "modular", "wall", "floor", "door", "pillar", "dungeon"])) {
+            addSkill(routes, "environment-kit", "Style-locked modular kit workflow.", 270);
+        }
+        else {
+            addSkill(routes, "prop-model", "Single static 3D prop workflow.", 270);
+        }
+        addSkill(routes, "scene-composition", "Instantiate/import models into robust scene structure.", 150);
+        if (animationIntent && includesAny(text, ["character", "player", "npc", "enemy", "boss", "humanoid", "rig"])) {
+            addSkill(routes, "generate-motion", "Generate idle/walk/run/jump/attack clips for the rigged character.", 275);
+            addSkill(routes, "animation-tree", "Wire generated clips into playback/state-machine behavior.", 210);
+        }
+    }
+    if (target === "3d" && !assetIntent) {
+        addSkill(routes, "scene-composition", "Build robust 3D scene structure.", 220);
+        addSkill(routes, "3d-lighting", "Give the scene readable camera, light, and environment defaults.", 180);
+    }
+    if (target === "2d" && assetIntent) {
+        if (includesAny(text, ["sprite sheet", "spritesheet", "run cycle", "frame grid"])) {
+            addSkill(routes, "sprite-sheet", "Frame grid/sprite animation workflow.", 280);
+        }
+        else if (includesAny(text, ["texture", "tile", "seamless", "wall", "floor"])) {
+            addSkill(routes, "tileable-texture", "Seamless texture generation and material use.", 260);
+        }
+        else if (includesAny(text, ["portrait", "dialogue", "bust"])) {
+            addSkill(routes, "character-portrait", "Polished dialogue portrait workflow.", 260);
+        }
+        else if (includesAny(text, ["ui", "hud", "button", "icon"])) {
+            addSkill(routes, "ui-graphics", "HUD/icon/UI image asset workflow.", 260);
+        }
+        else {
+            addSkill(routes, "concept-art", "Explore visual direction before final assets.", 220);
+        }
+    }
+    if (target === "audio" && assetIntent) {
+        if (includesAny(text, ["music", "theme", "track", "boss"])) {
+            addSkill(routes, "music-track", "Music generation workflow.", 280);
+        }
+        else if (includesAny(text, ["ambient", "ambience", "atmosphere"])) {
+            addSkill(routes, "ambient-bed", "Looping ambience workflow.", 260);
+        }
+        else if (includesAny(text, ["voice", "dialogue", "vo", "line"])) {
+            addSkill(routes, "voice-line", "Voice/dialogue generation workflow.", 260);
+        }
+        else {
+            addSkill(routes, "sound-effect", "One-shot SFX workflow.", 260);
+        }
+        addSkill(routes, "audio-direction", "Keep audio style coherent across the game.", 150);
+    }
+    if (target === "animation") {
+        addSkill(routes, "generate-motion", "Generate curated humanoid motion on a rigged character.", 280);
+        if (includesAny(text, ["blend", "state machine", "animationtree", "tree"])) {
+            addSkill(routes, "animation-tree", "Wire clips into an AnimationTree/state machine.", 260);
+        }
+        if (includesAny(text, ["retarget", "reuse", "another character"])) {
+            addSkill(routes, "retarget", "Reuse motion across compatible rigs.", 260);
+        }
+    }
+    if (target === "level") {
+        addSkill(routes, "design-level", "Build level structure, pacing, landmarks, and routes.", 270);
+        addSkill(routes, "scene-to-level", "Convert scene goals into playable level layout.", 210);
+        addSkill(routes, "scene-composition", "Use robust node/scene composition patterns.", 180);
+    }
+    if (target === "npc") {
+        addSkill(routes, "design-npc", "NPC behavior/dialogue integration workflow.", 270);
+        addSkill(routes, "gdscript-patterns", "Typed scripts/signals for NPC behavior.", 150);
+    }
+    if (target === "ui") {
+        addSkill(routes, "ui-basics", "HUD/menu/control composition workflow.", 270);
+        addSkill(routes, "gdscript-patterns", "Typed signal and state patterns for UI code.", 150);
+    }
+    if (target === "multiplayer") {
+        addSkill(routes, "setup-multiplayer", "Choose networking model before implementation.", 270);
+        addSkill(routes, "host-authoritative-state", "Server-authoritative state model.", 220);
+    }
+    if (includesAny(text, ["player controller", "fps", "first person", "wasd", "camera"])) {
+        addSkill(routes, "fps-controller", "Player controller, camera, collision, and input bindings.", 240);
+    }
+    if (includesAny(text, ["shooter", "arena shooter", "fps"])) {
+        addSkill(routes, "fps-controller", "Shooter input/camera/controller foundation.", 245);
+        addSkill(routes, "design-mechanic", "Implement the core shooting/combat loop.", 230);
+        addSkill(routes, "design-level", "Shape the arena, spawn space, cover, and pacing.", 210);
+    }
+    addSkill(routes, "gdscript-patterns", "Use direct host file edits for scripts, then verify through MCP.", 90);
+    addSkill(routes, "verification-before-completion", "Do not finish without a clean verification story.", 80);
+    return routes
+        .sort((a, b) => b.weight - a.weight)
+        .slice(0, 7)
+        .map((route) => {
+        const skill = SKILL_BY_NAME.get(route.name);
+        return {
+            id: `summer:${skill.category}/${skill.name}`,
+            name: skill.name,
+            category: skill.category,
+            why: route.why,
+            requiresMcpTools: skill.requiresMcpTools,
+        };
+    });
+}
+function buildMcpToolPlan(mode, target, assetPolicy, verification, goal = "") {
+    const text = goal.toLowerCase();
+    const animationIntent = includesAny(text, [
+        "animated",
+        "animation",
+        "animate",
+        "idle",
+        "walk",
+        "run",
+        "jump",
+        "attack",
+        "motion",
+        "mocap",
+        "locomotion",
+    ]);
+    const start = ["summer_start_game_task", "summer_get_project_context", "summer_get_agent_playbook"];
+    const mutate = ["summer_open_main_scene", "summer_get_scene_tree", "summer_add_node", "summer_set_prop", "summer_save_scene"];
+    const assets = [];
+    const verify = [];
+    if (mode === "debug") {
+        start.push("summer_get_diagnostics", "summer_get_script_errors", "summer_get_debugger_errors");
+    }
+    if (target === "animation") {
+        assets.push("summer_search_assets", "summer_get_asset", "summer_generate_motion");
+    }
+    else if (target === "3d" || target === "2d" || target === "audio") {
+        assets.push("summer_search_assets", "summer_list_my_assets", "summer_get_asset", "summer_import_asset_by_id");
+        if (assetPolicy !== "no-paid-generation") {
+            if (target === "3d")
+                assets.push("summer_generate_3d");
+            if (target === "2d")
+                assets.push("summer_generate_image");
+            if (target === "audio")
+                assets.push("summer_generate_audio");
+            if (target === "3d" && animationIntent)
+                assets.push("summer_generate_motion");
+            assets.push("summer_check_job");
+        }
+    }
+    else if (assetPolicy !== "no-paid-generation") {
+        assets.push("summer_search_assets", "summer_import_asset");
+    }
+    if (verification !== "none") {
+        verify.push("summer_get_script_errors", "summer_get_diagnostics");
+    }
+    if (verification === "full") {
+        verify.push("summer_clear_console", "summer_play", "summer_get_debugger_errors", "summer_stop");
+    }
+    return { start, mutate, assets, verify };
+}
+function buildUserGates(mode, assetPolicy) {
+    const gates = [
+        "Ask before destructive scene changes, deleting assets, or changing locked .summer memory.",
+    ];
+    if (assetPolicy !== "generate-when-clearly-needed") {
+        gates.push("Ask before paid generation, rigging, video, or large batch asset creation.");
+    }
+    if (mode === "new-game") {
+        gates.push("Lock one narrow playable loop before expanding scope.");
+    }
+    if (mode === "asset") {
+        gates.push("For generated 3D characters, show the unrigged preview before paid rigging.");
+    }
+    return gates;
+}
+export function buildGameTaskPlan(options) {
+    const goal = options.goal.trim();
+    if (!goal)
+        throw new Error("goal is required");
+    const assetPolicy = options.assetPolicy ?? "ask-before-paid-generation";
+    const verification = options.verification ?? "full";
+    const mode = inferMode(goal, options.mode ?? "auto");
+    const target = inferTarget(goal, options.target ?? "auto");
+    return {
+        goal,
+        mode,
+        target,
+        assetPolicy,
+        verification,
+        principles: [
+            "The agent should build a playable game slice, not a static demo.",
+            "Use host file edits for code/data/docs; use MCP for live scene state, imports, inspector values, play, and diagnostics.",
+            "Reuse/import assets before paid generation unless the user explicitly wants custom output.",
+            "Prefer exact IDs and structured tool results over search guesses after asset creation.",
+            "Verify through the engine before claiming completion.",
+        ],
+        recommendedSkills: inferSkills(mode, target, goal),
+        mcpToolPlan: buildMcpToolPlan(mode, target, assetPolicy, verification, goal),
+        hostFileWork: [
+            "Write and edit .gd/.cs scripts directly with host file tools.",
+            "Use direct file edits for JSON, markdown, project notes, and simple resources.",
+            "Read relevant .summer memory files when project context reports them.",
+        ],
+        userGates: buildUserGates(mode, assetPolicy),
+        nextAgentSteps: [
+            "Call summer_get_project_context and read relevant .summer memory.",
+            "Open the main scene if no scene is active.",
+            "Load the top recommended skill before mutating the project.",
+            "Make the smallest coherent change that advances the playable loop.",
+            "Save, run diagnostics, and playtest according to the verification level.",
+        ],
+        antiPatterns: [
+            "Do not hand-edit .tscn scene structure when Summer MCP can mutate the live scene.",
+            "Do not generate assets before checking library/user assets.",
+            "Do not search by name for an asset immediately after generation; use the returned asset ID.",
+            "Do not finish with only code changes when the request affects gameplay; run engine verification.",
+        ],
+    };
+}

package/dist/lib/project-memory.d.ts

@@ -0,0 +1,33 @@
+export interface ProjectMemoryFileSummary {
+    path: string;
+    kind: string;
+    title: string | null;
+    modifiedTime: string;
+    bytes: number;
+    locked: boolean;
+}
+export interface ProjectMemorySummary {
+    present: boolean;
+    root: ".summer";
+    reason?: string;
+    canonical: {
+        gameSoul: ProjectMemoryFileSummary | null;
+        artBible: ProjectMemoryFileSummary | null;
+        audioBible: ProjectMemoryFileSummary | null;
+        buildPlan: ProjectMemoryFileSummary | null;
+        legacyVoiceCast: ProjectMemoryFileSummary | null;
+    };
+    structured: {
+        present: boolean;
+        indexPresent: boolean;
+        fileCount: number;
+        lockedCount: number;
+        files: ProjectMemoryFileSummary[];
+        truncated: boolean;
+    };
+    files: ProjectMemoryFileSummary[];
+    guidance: string;
+}
+export declare function getProjectMemorySummary(projectPath: string | null | undefined, options?: {
+    maxFiles?: number;
+}): ProjectMemorySummary;

package/dist/lib/project-memory.js

@@ -0,0 +1,220 @@
+import { closeSync, existsSync, openSync, readSync, readdirSync, statSync, } from "node:fs";
+import { join, relative, sep } from "node:path";
+const CANONICAL_FILES = [
+    { key: "gameSoul", relativePath: ".summer/GameSoul.md", kind: "brief" },
+    { key: "artBible", relativePath: ".summer/art-bible.md", kind: "art" },
+    { key: "audioBible", relativePath: ".summer/audio-bible.md", kind: "audio" },
+    { key: "buildPlan", relativePath: ".summer/build-plan.md", kind: "build-plan" },
+    { key: "legacyVoiceCast", relativePath: ".summer/voice-cast.md", kind: "legacy-casting" },
+];
+const SKIPPED_DIRS = new Set(["skills", "local"]);
+const DEFAULT_MAX_FILES = 30;
+const MAX_TITLE_BYTES = 16_384;
+export function getProjectMemorySummary(projectPath, options = {}) {
+    const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
+    const empty = createEmptySummary();
+    if (!projectPath) {
+        return {
+            ...empty,
+            reason: "Project path is not available from the running engine.",
+        };
+    }
+    const summerDir = join(projectPath, ".summer");
+    if (!existsSync(summerDir)) {
+        return {
+            ...empty,
+            reason: "No .summer directory found yet.",
+        };
+    }
+    const canonical = createCanonicalSummary(projectPath);
+    const allFiles = scanMarkdownFiles(projectPath, summerDir, maxFiles);
+    const memoryDir = join(projectPath, ".summer", "memory");
+    const structuredFiles = existsSync(memoryDir)
+        ? scanMarkdownFiles(projectPath, memoryDir, maxFiles)
+        : [];
+    const indexPath = join(projectPath, ".summer", "memory", "index.json");
+    return {
+        present: true,
+        root: ".summer",
+        canonical,
+        structured: {
+            present: existsSync(memoryDir),
+            indexPresent: existsSync(indexPath),
+            fileCount: Math.min(structuredFiles.length, maxFiles),
+            lockedCount: structuredFiles.filter((file) => file.locked).length,
+            files: structuredFiles.slice(0, maxFiles),
+            truncated: structuredFiles.length > maxFiles,
+        },
+        files: allFiles.slice(0, maxFiles),
+        guidance: "Read relevant .summer Markdown before creative, audio, dialogue, level, or character work. Ask before writing .summer files. Changing priority: locked memory requires explicit user confirmation.",
+    };
+}
+function createEmptySummary() {
+    return {
+        present: false,
+        root: ".summer",
+        canonical: {
+            gameSoul: null,
+            artBible: null,
+            audioBible: null,
+            buildPlan: null,
+            legacyVoiceCast: null,
+        },
+        structured: {
+            present: false,
+            indexPresent: false,
+            fileCount: 0,
+            lockedCount: 0,
+            files: [],
+            truncated: false,
+        },
+        files: [],
+        guidance: "Create .summer/GameSoul.md for the project brief. Use .summer/memory/ for locked facts such as character voice IDs, world canon, and provider bindings.",
+    };
+}
+function createCanonicalSummary(projectPath) {
+    const canonical = createEmptySummary().canonical;
+    for (const spec of CANONICAL_FILES) {
+        const absolutePath = join(projectPath, ...spec.relativePath.split("/"));
+        canonical[spec.key] = summarizeFile(projectPath, absolutePath, spec.kind);
+    }
+    return canonical;
+}
+function scanMarkdownFiles(projectPath, startDir, maxFiles) {
+    const files = [];
+    walkSummerDir(projectPath, startDir, startDir, files, maxFiles + 1, 0);
+    return files;
+}
+function walkSummerDir(projectPath, summerDir, currentDir, files, maxFiles, depth) {
+    if (files.length >= maxFiles || depth > 5)
+        return;
+    let entries;
+    try {
+        entries = readdirSync(currentDir).sort();
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (files.length >= maxFiles)
+            return;
+        const absolutePath = join(currentDir, entry);
+        let stat;
+        try {
+            stat = statSync(absolutePath);
+        }
+        catch {
+            continue;
+        }
+        if (stat.isDirectory()) {
+            const relativeToSummer = relative(summerDir, absolutePath);
+            if (depth === 0 && SKIPPED_DIRS.has(relativeToSummer))
+                continue;
+            walkSummerDir(projectPath, summerDir, absolutePath, files, maxFiles, depth + 1);
+            continue;
+        }
+        if (!stat.isFile() || !entry.endsWith(".md"))
+            continue;
+        const summary = summarizeFile(projectPath, absolutePath, kindForPath(projectPath, absolutePath));
+        if (summary)
+            files.push(summary);
+    }
+}
+function summarizeFile(projectPath, absolutePath, kind) {
+    if (!existsSync(absolutePath))
+        return null;
+    let stat;
+    try {
+        stat = statSync(absolutePath);
+    }
+    catch {
+        return null;
+    }
+    if (!stat.isFile())
+        return null;
+    const preview = readPreview(absolutePath);
+    return {
+        path: normalizePath(relative(projectPath, absolutePath)),
+        kind,
+        title: extractTitle(preview),
+        modifiedTime: stat.mtime.toISOString(),
+        bytes: stat.size,
+        locked: isLockedMemory(preview),
+    };
+}
+function readPreview(absolutePath) {
+    let fd = null;
+    try {
+        fd = openSync(absolutePath, "r");
+        const buffer = Buffer.alloc(MAX_TITLE_BYTES);
+        const bytesRead = readSync(fd, buffer, 0, MAX_TITLE_BYTES, 0);
+        return buffer.toString("utf-8", 0, bytesRead);
+    }
+    catch {
+        return "";
+    }
+    finally {
+        if (fd !== null) {
+            try {
+                closeSync(fd);
+            }
+            catch {
+                // Best-effort summary only.
+            }
+        }
+    }
+}
+function extractTitle(markdown) {
+    for (const line of markdown.split(/\r?\n/)) {
+        const heading = line.match(/^#\s+(.+?)\s*$/);
+        if (heading)
+            return heading[1];
+    }
+    for (const line of markdown.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed && trimmed !== "---" && !trimmed.includes(":")) {
+            return trimmed.slice(0, 120);
+        }
+    }
+    return null;
+}
+function isLockedMemory(markdown) {
+    return (/^priority:\s*locked\s*$/im.test(markdown) ||
+        /^stable:\s*true\s*$/im.test(markdown) ||
+        /\|\s*locked\s*\|/i.test(markdown));
+}
+function kindForPath(projectPath, absolutePath) {
+    const path = normalizePath(relative(projectPath, absolutePath));
+    if (path === ".summer/GameSoul.md")
+        return "brief";
+    if (path === ".summer/art-bible.md")
+        return "art";
+    if (path === ".summer/audio-bible.md")
+        return "audio";
+    if (path === ".summer/build-plan.md")
+        return "build-plan";
+    if (path === ".summer/voice-cast.md")
+        return "legacy-casting";
+    if (path.startsWith(".summer/memory/casting/"))
+        return "casting";
+    if (path.startsWith(".summer/memory/characters/"))
+        return "character";
+    if (path.startsWith(".summer/memory/world/"))
+        return "world";
+    if (path.startsWith(".summer/memory/systems/"))
+        return "system";
+    if (path.startsWith(".summer/memory/decisions/"))
+        return "decision";
+    if (path.startsWith(".summer/memory/conflicts/"))
+        return "conflict";
+    if (path.startsWith(".summer/mechanics/"))
+        return "mechanic";
+    if (path.startsWith(".summer/levels/"))
+        return "level";
+    if (path.startsWith(".summer/npcs/"))
+        return "npc";
+    return "note";
+}
+function normalizePath(path) {
+    return path.split(sep).join("/");
+}