@happyvertical/smrt-planner 0.0.0-stage → 0.0.2

package/dist/planner/commands/controller.svelte.js

@@ -0,0 +1,77 @@
+import { untrack } from 'svelte';
+import { cookbookStore, } from "../../cookbook/store.svelte.js";
+import { parseCookbook } from "../../cookbook/validate.js";
+import { setSamplePack } from "../../data/packs.js";
+import { libraryState } from "../../library/state.svelte.js";
+import { createPlannerAdapter, } from "./adapter.js";
+import { engineCatalog } from "./catalog.js";
+/** A reactive cell: reading it in an effect subscribes to it. */
+function reactiveCell(initial) {
+    let value = $state(initial);
+    return {
+        get: () => value,
+        set: (next) => {
+            value = next;
+        },
+    };
+}
+/** The app's stores as the engine's port: where the document is read and written. */
+export function portFromStore(store) {
+    return {
+        read: () => store.snapshot(),
+        applied: () => libraryState.active,
+        prepareImport: (document) => parseCookbook(document),
+        write(cookbook, { replaced, applied, libraryApplied }) {
+            // A page's customisations are edited outside the plan; only a command
+            // that replaces the whole app brings its own.
+            const next = replaced
+                ? cookbook
+                : { ...cookbook, overviews: store.snapshot().overviews };
+            if (replaced)
+                store.replace(next);
+            else
+                store.apply(next);
+            if (libraryApplied && applied) {
+                libraryState.select(applied);
+                setSamplePack(applied);
+            }
+        },
+    };
+}
+/**
+ * The controller for the planner app over `store` (the app's is
+ * `cookbookStore`): smrt's cookbook engine behind the planner's command names,
+ * with the stores as its document and the planner tab and section as `focus`.
+ * Every UI path that changes the app is a command here, and the assistant, the
+ * palette, a host page and the MCP and CLI servers use the same ones.
+ */
+export function createPlannerController(store = cookbookStore, options = {}) {
+    let stopEffects;
+    const adapter = createPlannerAdapter({
+        catalog: engineCatalog(),
+        port: portFromStore(store),
+        options,
+        env: {
+            section: reactiveCell(null),
+            tab: reactiveCell(null),
+            watch: {
+                start() {
+                    if (stopEffects)
+                        return;
+                    stopEffects = $effect.root(() => {
+                        $effect(() => {
+                            // Reading the snapshot subscribes to every store it is built from.
+                            adapter.observe();
+                            untrack(adapter.deliver);
+                        });
+                    });
+                },
+                stop() {
+                    stopEffects?.();
+                    stopEffects = undefined;
+                },
+            },
+        },
+    });
+    return adapter;
+}

package/dist/planner/commands/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The planner command set: smrt's cookbook command engine
+ * (`@happyvertical/smrt-core/cookbook/engine`) behind the planner's names, plus
+ * `focus`; typed, versioned commands that drive the planner, a compact snapshot
+ * of its state, and JSON Schemas for every command's input (use `commandTools`
+ * directly as LLM or MCP tool definitions).
+ *
+ * @module
+ */
+export { type Cell, createPlannerAdapter, type PlannerAdapter, type PlannerAdapterOptions, type PlannerController, type PlannerControllerOptions, type PlannerNavigation, type PlannerPort, } from './adapter.ts';
+export { buildEngineCatalog, engineCatalog, restrictCatalog, } from './catalog.ts';
+export { createPlannerController, portFromStore, } from './controller.svelte.ts';
+export { buildCommandTools, COMMAND_NAMES, type CommandTool, checkSchema, commandSchemas, commandTools, type JsonSchema, } from './schemas.ts';
+export { createSliceController, portFromSlices } from './slices.ts';
+export { type BatchResult, type CommandError, type CommandErrorCode, type CommandInputs, type CommandName, type CommandReceipt, type CommandResult, type ExportData, PLANNER_COMMANDS_VERSION, PLANNER_TAB_IDS, type PlannerCommand, type PlannerTabId, type PlanSnapshot, type RecipeChanges, type RunOptions, } from './types.ts';

package/dist/planner/commands/index.js

@@ -0,0 +1,15 @@
+/**
+ * The planner command set: smrt's cookbook command engine
+ * (`@happyvertical/smrt-core/cookbook/engine`) behind the planner's names, plus
+ * `focus`; typed, versioned commands that drive the planner, a compact snapshot
+ * of its state, and JSON Schemas for every command's input (use `commandTools`
+ * directly as LLM or MCP tool definitions).
+ *
+ * @module
+ */
+export { createPlannerAdapter, } from "./adapter.js";
+export { buildEngineCatalog, engineCatalog, restrictCatalog, } from "./catalog.js";
+export { createPlannerController, portFromStore, } from "./controller.svelte.js";
+export { buildCommandTools, COMMAND_NAMES, checkSchema, commandSchemas, commandTools, } from "./schemas.js";
+export { createSliceController, portFromSlices } from "./slices.js";
+export { PLANNER_COMMANDS_VERSION, PLANNER_TAB_IDS, } from "./types.js";

package/dist/planner/commands/schemas.d.ts

@@ -0,0 +1,25 @@
+import { type EngineCatalog, type CommandTool as EngineCommandTool, type JsonSchema } from '@happyvertical/smrt-core/cookbook/engine';
+import { type CommandName } from './types.ts';
+export type { JsonSchema };
+/** One command as an LLM or MCP tool definition. */
+export interface CommandTool extends Omit<EngineCommandTool, 'name'> {
+    name: CommandName;
+}
+/** The engine's tools for `catalog`, with the planner's `focus` after them. */
+export declare function toolsFor(catalog: EngineCatalog): CommandTool[];
+/**
+ * Build every command's tool definition. `recipeIds` and `cookbookIds` become
+ * enums, so grammar-constrained decoding cannot name one that does not exist.
+ */
+export declare function buildCommandTools(recipeIds: readonly string[], cookbookIds: readonly string[]): CommandTool[];
+/** Every command as a tool definition, for the planner's own recipes and cookbooks. */
+export declare const commandTools: readonly CommandTool[];
+/** Every command's input JSON Schema, by name: ready to use as a tool's `inputSchema`. */
+export declare const commandSchemas: Readonly<Record<CommandName, JsonSchema>>;
+export declare const COMMAND_NAMES: readonly CommandName[];
+/**
+ * Check a value against a command schema. Returns the first problem as a
+ * sentence naming the path, or null. The engine's own validator, so the
+ * exported schemas and the runtime cannot drift.
+ */
+export declare function checkSchema(schema: JsonSchema, value: unknown, path?: string): string | null;

package/dist/planner/commands/schemas.js

@@ -0,0 +1,67 @@
+import { buildCommandTools as buildEngineTools, checkSchema as checkEngineSchema, } from '@happyvertical/smrt-core/cookbook/engine';
+import { libraryCookbooks } from "../../library/index.js";
+import { recipes } from "../../recipes/index.js";
+import { engineCatalog } from "./catalog.js";
+import { PLANNER_TAB_IDS } from "./types.js";
+/**
+ * `focus` is the one command the planner adds to the engine's: it moves the
+ * view, not the document, so the engine has no such command.
+ */
+const FOCUS_TOOL = {
+    name: 'focus',
+    description: "Move the planner's view to a tab and/or a menu section. Navigation only; it changes nothing in the plan.",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            tab: {
+                enum: [...PLANNER_TAB_IDS],
+                description: 'The tab to open.',
+            },
+            section: {
+                type: 'string',
+                minLength: 1,
+                maxLength: 200,
+                description: 'The id of a menu section, as the plan snapshot\'s "sections" lists it.',
+            },
+        },
+        additionalProperties: false,
+    },
+};
+/** The engine's tools for `catalog`, with the planner's `focus` after them. */
+export function toolsFor(catalog) {
+    return [...buildEngineTools(catalog), FOCUS_TOOL];
+}
+/**
+ * Build every command's tool definition. `recipeIds` and `cookbookIds` become
+ * enums, so grammar-constrained decoding cannot name one that does not exist.
+ */
+export function buildCommandTools(recipeIds, cookbookIds) {
+    return toolsFor({
+        ...engineCatalog(),
+        recipes: recipeIds.map((id) => ({
+            id,
+            label: id,
+            models: [],
+            nav: [],
+            requires: [],
+        })),
+        cookbooks: cookbookIds.map((id) => ({
+            id,
+            name: id,
+            document: {},
+        })),
+    });
+}
+/** Every command as a tool definition, for the planner's own recipes and cookbooks. */
+export const commandTools = buildCommandTools(recipes.map((recipe) => recipe.id), libraryCookbooks.map((cookbook) => cookbook.id));
+/** Every command's input JSON Schema, by name: ready to use as a tool's `inputSchema`. */
+export const commandSchemas = Object.fromEntries(commandTools.map((tool) => [tool.name, tool.inputSchema]));
+export const COMMAND_NAMES = commandTools.map((tool) => tool.name);
+/**
+ * Check a value against a command schema. Returns the first problem as a
+ * sentence naming the path, or null. The engine's own validator, so the
+ * exported schemas and the runtime cannot drift.
+ */
+export function checkSchema(schema, value, path = 'input') {
+    return checkEngineSchema(schema, value, path)?.message ?? null;
+}

package/dist/planner/commands/slices.d.ts

@@ -0,0 +1,18 @@
+import type { RecipeStore, SettingsStore, ThemeStore } from '../../assistant/change.ts';
+import { type PlannerController, type PlannerControllerOptions, type PlannerPort } from './adapter.ts';
+/**
+ * Just the slices of the app the assistant works with (recipes, settings and
+ * theme) as the engine's document, for hosts that have no more than that and for
+ * tests. A command changes the slices through their own `add`/`remove`/`write`.
+ */
+export declare function portFromSlices(slices: {
+    store: RecipeStore;
+    settings?: SettingsStore;
+    theme?: ThemeStore;
+}): PlannerPort;
+/** The controller over just a recipe store and, optionally, settings and theme. */
+export declare function createSliceController(slices: {
+    store: RecipeStore;
+    settings?: SettingsStore;
+    theme?: ThemeStore;
+}, options?: PlannerControllerOptions): PlannerController;

package/dist/planner/commands/slices.js

@@ -0,0 +1,49 @@
+import { COOKBOOK_SCHEMA } from "../../cookbook/types.js";
+import { readSettings, writeSettings } from "../../settings/app-settings.js";
+import { createPlannerAdapter, } from "./adapter.js";
+import { engineCatalog } from "./catalog.js";
+const empty = () => ({
+    $schema: COOKBOOK_SCHEMA,
+    version: 1,
+    recipes: [],
+    features: [],
+    policies: [],
+});
+/**
+ * Just the slices of the app the assistant works with (recipes, settings and
+ * theme) as the engine's document, for hosts that have no more than that and for
+ * tests. A command changes the slices through their own `add`/`remove`/`write`.
+ */
+export function portFromSlices(slices) {
+    const { store, settings, theme } = slices;
+    return {
+        read() {
+            let doc = { ...empty(), recipes: [...store.ids].sort() };
+            if (settings)
+                doc = writeSettings(doc, settings.read());
+            const look = theme?.read();
+            return look ? { ...doc, theme: look } : doc;
+        },
+        write(next) {
+            const want = new Set(next.recipes);
+            const have = new Set(store.ids);
+            const extra = [...have].filter((id) => !want.has(id));
+            if (extra.length)
+                store.remove(...extra);
+            const missing = [...want].filter((id) => !have.has(id));
+            if (missing.length)
+                store.add(...missing);
+            if (settings)
+                settings.write(readSettings(next));
+            theme?.write(next.theme);
+        },
+    };
+}
+/** The controller over just a recipe store and, optionally, settings and theme. */
+export function createSliceController(slices, options = {}) {
+    return createPlannerAdapter({
+        catalog: engineCatalog(),
+        port: portFromSlices(slices),
+        options,
+    });
+}

package/dist/planner/commands/types.d.ts

@@ -0,0 +1,80 @@
+import type { CommandError as EngineCommandError, CommandInputs as EngineCommandInputs, CommandReceipt as EngineCommandReceipt, PlanSnapshot as EnginePlanSnapshot, ExportData, RecipeChanges, RunOptions } from '@happyvertical/smrt-core/cookbook/engine';
+export { COOKBOOK_COMMANDS_VERSION as PLANNER_COMMANDS_VERSION } from '@happyvertical/smrt-core/cookbook/engine';
+export type { ExportData, RecipeChanges, RunOptions };
+/** The planner's tabs, in order. Navigation only; never part of the cookbook. */
+export declare const PLANNER_TAB_IDS: readonly ["cookbooks", "recipes", "features", "layout", "settings", "export"];
+export type PlannerTabId = (typeof PLANNER_TAB_IDS)[number];
+/** Input of each command, keyed by the command's (tool) name. */
+export interface CommandInputs extends EngineCommandInputs {
+    /** Move the planner's focus to a tab and/or a section. Not a document change. */
+    focus: {
+        tab?: PlannerTabId;
+        section?: string;
+    };
+}
+export type CommandName = keyof CommandInputs;
+/** One command: its name and input. The unit `controller.run` takes. */
+export type PlannerCommand = {
+    [N in CommandName]: {
+        name: N;
+        input: CommandInputs[N];
+        /** Retry key: a repeated id returns the first receipt and applies nothing. */
+        id?: string;
+        /** Refuse with `conflict` unless the plan is still at this revision. */
+        expectedRevision?: number;
+    };
+}[CommandName];
+/** Why a command did not run (the engine's codes). */
+export type CommandError = EngineCommandError;
+export type CommandErrorCode = EngineCommandError['code'];
+/** The engine's snapshot, plus where the planner is looking. */
+export interface PlanSnapshot extends EnginePlanSnapshot {
+    /** Where the planner is looking; not saved. */
+    focus: {
+        tab: PlannerTabId | null;
+        section: string | null;
+    };
+}
+/** The engine's receipt; its `name` may also be `focus`. */
+export interface CommandReceipt extends Omit<EngineCommandReceipt, 'name'> {
+    name: CommandName;
+}
+export type CommandResult = {
+    ok: true;
+    id?: string;
+    /** True when this is the stored result of an earlier run of the same id. */
+    replayed?: boolean;
+    snapshot: PlanSnapshot;
+    receipt: CommandReceipt;
+    /** Extra output: `export_cookbook` returns the file, `validate` the diagnostics. */
+    data?: unknown;
+} | {
+    ok: false;
+    id?: string;
+    replayed?: boolean;
+    error: CommandError;
+};
+/** Several commands applied all-or-nothing (`engine.batch`). */
+export type BatchResult = {
+    ok: true;
+    id?: string;
+    replayed?: boolean;
+    snapshot: PlanSnapshot;
+    receipt: {
+        id?: string;
+        count: number;
+        changed: boolean;
+        revisionBefore: number;
+        revisionAfter: number;
+        undoId?: string;
+    };
+    results: Extract<CommandResult, {
+        ok: true;
+    }>[];
+} | {
+    ok: false;
+    id?: string;
+    replayed?: boolean;
+    error: CommandError;
+    snapshot: PlanSnapshot;
+};

package/dist/planner/commands/types.js

@@ -0,0 +1,18 @@
+/*
+ * The planner command set is smrt's cookbook command engine
+ * (`@happyvertical/smrt-core/cookbook/engine`, #3753) plus `focus`, the one
+ * command that is about the planner's own view and not the document. Types,
+ * errors, receipts and the snapshot are the engine's; this file only adds what
+ * the planner puts on top. `docs/inference-host.md` lists the differences from
+ * the v1 command set the planner shipped before the engine.
+ */
+export { COOKBOOK_COMMANDS_VERSION as PLANNER_COMMANDS_VERSION } from '@happyvertical/smrt-core/cookbook/engine';
+/** The planner's tabs, in order. Navigation only; never part of the cookbook. */
+export const PLANNER_TAB_IDS = [
+    'cookbooks',
+    'recipes',
+    'features',
+    'layout',
+    'settings',
+    'export',
+];

package/dist/planner/create.d.ts

@@ -0,0 +1,4 @@
+/** Ask the page at `path` (a pathname, any query ignored) to open New. */
+export declare function requestCreate(path: string, now?: number): void;
+/** True once, on the page the request named, shortly after it was made. */
+export declare function takeCreate(path: string, now?: number): boolean;

package/dist/planner/create.js

@@ -0,0 +1,22 @@
+/**
+ * "New <noun>" on a section's page opens the entry page with its create form
+ * already open. The request is remembered here, not in the URL (the address
+ * bar mirrors only the shareable state), and the entry page takes it once its
+ * list has loaded. It names the page it is for and expires, so a navigation
+ * that never happened cannot open a form on a later visit.
+ */
+const TTL_MS = 5000;
+let pending;
+/** Ask the page at `path` (a pathname, any query ignored) to open New. */
+export function requestCreate(path, now = Date.now()) {
+    pending = { path: pathOf(path), at: now };
+}
+/** True once, on the page the request named, shortly after it was made. */
+export function takeCreate(path, now = Date.now()) {
+    const request = pending;
+    pending = undefined;
+    return (!!request && request.path === pathOf(path) && now - request.at <= TTL_MS);
+}
+function pathOf(href) {
+    return href.split(/[?#]/)[0] ?? href;
+}

package/dist/planner/instance.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Things only the running app can do, set by its layout: the controller calls
+ * them after a command that needs them. Unset, the command still succeeds.
+ */
+export declare const plannerRuntime: {
+    /** Regenerate the sample records after a cookbook replaced the app. */
+    onReplaced?: () => void;
+    /** Open a menu section's page (`focus` with a `section`). */
+    openSection?: (sectionId: string) => void;
+};
+/**
+ * The app's one planner controller: the assistant, the palette, a host page
+ * and (later) the MCP and CLI servers all drive the planner through it.
+ */
+export declare const plannerController: import("./commands/adapter.ts").PlannerController & Pick<import("./commands/adapter.ts").PlannerAdapter, "undo" | "cookbook" | "tools">;

package/dist/planner/instance.js

@@ -0,0 +1,22 @@
+import { cookbookStore } from "../cookbook/store.svelte.js";
+import { createPlannerController } from "./commands/index.js";
+import { plannerTab } from "./tab.svelte.js";
+/**
+ * Things only the running app can do, set by its layout: the controller calls
+ * them after a command that needs them. Unset, the command still succeeds.
+ */
+export const plannerRuntime = {};
+/**
+ * The app's one planner controller: the assistant, the palette, a host page
+ * and (later) the MCP and CLI servers all drive the planner through it.
+ */
+export const plannerController = createPlannerController(cookbookStore, {
+    navigation: {
+        getTab: () => plannerTab.active,
+        setTab: (tab) => {
+            plannerTab.active = tab;
+        },
+        setSection: (id) => plannerRuntime.openSection?.(id),
+    },
+    onReplaced: () => plannerRuntime.onReplaced?.(),
+});

package/dist/planner/query.d.ts

@@ -0,0 +1,16 @@
+/** The query parameter naming the Planner's active tab: `?tab=layout`. */
+export declare const TAB_PARAM = "tab";
+export interface QueryParts {
+    packages: readonly string[];
+}
+/**
+ * The one place the shareable URL state becomes a query string. Only the
+ * package selection lives in the URL: recipes, options and the layout are the
+ * cookbook, saved in localStorage (`cookbook/`). The Planner's tab is added
+ * by `withTab`, only on the Planner page.
+ */
+export declare function composeQuery(parts: QueryParts): string;
+/** Does this query string carry a package selection? */
+export declare function hasAppState(search: string): boolean;
+/** Add `?tab=` to a query string, keeping every other parameter. */
+export declare function withTab(query: string, tab: string): string;

package/dist/planner/query.js

@@ -0,0 +1,28 @@
+import { SELECTION_PARAM } from "./selection.js";
+/** The query parameter naming the Planner's active tab: `?tab=layout`. */
+export const TAB_PARAM = 'tab';
+/**
+ * The one place the shareable URL state becomes a query string. Only the
+ * package selection lives in the URL: recipes, options and the layout are the
+ * cookbook, saved in localStorage (`cookbook/`). The Planner's tab is added
+ * by `withTab`, only on the Planner page.
+ */
+export function composeQuery(parts) {
+    return parts.packages.length
+        ? `?${SELECTION_PARAM}=${[...parts.packages].sort().join(',')}`
+        : '';
+}
+/** Does this query string carry a package selection? */
+export function hasAppState(search) {
+    return new URLSearchParams(search).has(SELECTION_PARAM);
+}
+/** Add `?tab=` to a query string, keeping every other parameter. */
+export function withTab(query, tab) {
+    const params = new URLSearchParams(query);
+    if (tab === 'recipes')
+        params.delete(TAB_PARAM);
+    else
+        params.set(TAB_PARAM, tab);
+    const out = params.toString().replace(/%2C/gi, ',');
+    return out ? `?${out}` : '';
+}

package/dist/planner/selection.d.ts

@@ -0,0 +1,15 @@
+import type { CatalogPackage } from '../catalog/types.ts';
+/** The URL query parameter that carries the selection: `?p=products,sales`. */
+export declare const SELECTION_PARAM = "p";
+/** Parse the selection out of a query string, keeping only known package ids. */
+export declare function parseSelection(search: string, known: ReadonlySet<string>): string[];
+/** Sorted and de-duplicated, so the same selection is always the same URL. */
+export declare function normalize(ids: Iterable<string>): string[];
+/** `?p=a,b`, or the empty string for an empty selection. */
+export declare function selectionQuery(ids: readonly string[]): string;
+/** Append the selection to an in-app path so it survives navigation. */
+export declare function withSelection(path: string, ids: readonly string[]): string;
+/** `ids` plus everything they transitively depend on, as a sorted set. */
+export declare function withDependencies(ids: Iterable<string>, packages: ReadonlyMap<string, CatalogPackage>): string[];
+/** Ids of the selected packages that depend (directly) on `id`. */
+export declare function requiredBy(id: string, selected: readonly string[], packages: ReadonlyMap<string, CatalogPackage>): string[];

package/dist/planner/selection.js

@@ -0,0 +1,38 @@
+/** The URL query parameter that carries the selection: `?p=products,sales`. */
+export const SELECTION_PARAM = 'p';
+/** Parse the selection out of a query string, keeping only known package ids. */
+export function parseSelection(search, known) {
+    const value = new URLSearchParams(search).get(SELECTION_PARAM) ?? '';
+    return normalize(value.split(',').filter((id) => known.has(id)));
+}
+/** Sorted and de-duplicated, so the same selection is always the same URL. */
+export function normalize(ids) {
+    return [...new Set(ids)].sort();
+}
+/** `?p=a,b`, or the empty string for an empty selection. */
+export function selectionQuery(ids) {
+    return ids.length ? `?${SELECTION_PARAM}=${normalize(ids).join(',')}` : '';
+}
+/** Append the selection to an in-app path so it survives navigation. */
+export function withSelection(path, ids) {
+    return `${path}${selectionQuery(ids)}`;
+}
+/** `ids` plus everything they transitively depend on, as a sorted set. */
+export function withDependencies(ids, packages) {
+    const result = new Set();
+    const visit = (id) => {
+        const pkg = packages.get(id);
+        if (!pkg || result.has(id))
+            return;
+        result.add(id);
+        for (const dependency of pkg.dependencies)
+            visit(dependency);
+    };
+    for (const id of ids)
+        visit(id);
+    return normalize(result);
+}
+/** Ids of the selected packages that depend (directly) on `id`. */
+export function requiredBy(id, selected, packages) {
+    return selected.filter((other) => other !== id && packages.get(other)?.dependencies.includes(id));
+}

package/dist/planner/selection.svelte.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The visitor's chosen packages: the one piece of state the control panel, the
+ * generated navigation and (later) the chat assistant all read and write.
+ *
+ * The URL (`?p=...`) is the persisted form; the layout keeps the two in sync.
+ * Anything that changes the selection goes through `add`, `remove` or
+ * `apply`, so a future chat transport can drive it exactly like the panel.
+ */
+declare class Selection {
+    ids: string[];
+    has(id: string): boolean;
+    /** Selected packages that need `id`; non-empty means it cannot be removed. */
+    requiredBy(id: string): string[];
+    /** Replace the selection from a URL query string. */
+    fromSearch(search: string): void;
+    /** Select packages, pulling in their dependencies. */
+    add(...ids: string[]): void;
+    /** Deselect packages; ones other selected packages need are kept. */
+    remove(...ids: string[]): void;
+    toggle(id: string): void;
+    /** Apply an `{ add, remove }` change (the shape the chat assistant emits). */
+    apply(change: {
+        add?: string[];
+        remove?: string[];
+    }): void;
+    clear(): void;
+}
+export declare const selection: Selection;
+export {};

package/dist/planner/selection.svelte.js

@@ -0,0 +1,54 @@
+import { catalog } from "../catalog/index.js";
+import { normalize, parseSelection, requiredBy, withDependencies, } from "./selection.js";
+const packages = new Map(catalog.packages.map((pkg) => [pkg.id, pkg]));
+const known = new Set(packages.keys());
+/**
+ * The visitor's chosen packages: the one piece of state the control panel, the
+ * generated navigation and (later) the chat assistant all read and write.
+ *
+ * The URL (`?p=...`) is the persisted form; the layout keeps the two in sync.
+ * Anything that changes the selection goes through `add`, `remove` or
+ * `apply`, so a future chat transport can drive it exactly like the panel.
+ */
+class Selection {
+    ids = $state([]);
+    has(id) {
+        return this.ids.includes(id);
+    }
+    /** Selected packages that need `id`; non-empty means it cannot be removed. */
+    requiredBy(id) {
+        return requiredBy(id, this.ids, packages);
+    }
+    /** Replace the selection from a URL query string. */
+    fromSearch(search) {
+        this.ids = withDependencies(parseSelection(search, known), packages);
+    }
+    /** Select packages, pulling in their dependencies. */
+    add(...ids) {
+        this.ids = withDependencies([...this.ids, ...ids], packages);
+    }
+    /** Deselect packages; ones other selected packages need are kept. */
+    remove(...ids) {
+        const removing = new Set(ids);
+        let remaining = this.ids.filter((id) => !removing.has(id));
+        // A package whose dependency was just removed would be orphaned; keep the
+        // dependency instead of silently dropping the dependant.
+        remaining = withDependencies(remaining, packages);
+        this.ids = normalize(remaining);
+    }
+    toggle(id) {
+        if (this.has(id))
+            this.remove(id);
+        else
+            this.add(id);
+    }
+    /** Apply an `{ add, remove }` change (the shape the chat assistant emits). */
+    apply(change) {
+        this.add(...(change.add ?? []).filter((id) => known.has(id)));
+        this.remove(...(change.remove ?? []));
+    }
+    clear() {
+        this.ids = [];
+    }
+}
+export const selection = new Selection();

package/dist/planner/tab.svelte.d.ts

@@ -0,0 +1,11 @@
+export declare const PLANNER_TABS: readonly ["cookbooks", "recipes", "features", "layout", "settings", "export"];
+export type PlannerTab = (typeof PLANNER_TABS)[number];
+/** `fallback` (Recipes) unless the query names another known tab. */
+export declare function parseTab(search: string, fallback?: PlannerTab): PlannerTab;
+/** The Planner page's active tab; the address bar mirrors it (`?tab=`). */
+declare class PlannerTabState {
+    active: "export" | "settings" | "features" | "recipes" | "layout" | "cookbooks";
+    fromSearch(search: string, fallback?: PlannerTab): void;
+}
+export declare const plannerTab: PlannerTabState;
+export {};