@happyvertical/smrt-planner 0.0.0-stage → 0.0.1

package/dist/ai/state.svelte.js

@@ -0,0 +1,286 @@
+import { getModel, shortLabel } from "../assistant/models.js";
+import { AssistantSession, } from "../assistant/session.svelte.js";
+import { loadVoiceConsent, VoiceSession, } from "../assistant/voice.svelte.js";
+import { ByoModel } from "../inference/byo.svelte.js";
+import { DEFAULT_INFERENCE, } from "../inference/config.js";
+import { createHostChat } from "../inference/host.js";
+import { createSliceController } from "../planner/commands/index.js";
+import { deriveCapabilities, needsFirstRunSetup, } from "./status.js";
+export const AI_PREFS_KEY = 'smrt-planner:ai:v1';
+export function loadAiPrefs(storage) {
+    const prefs = {
+        dismissed: false,
+        readAloud: false,
+        handsFree: false,
+        sendOnPause: false,
+    };
+    try {
+        const raw = storage?.getItem(AI_PREFS_KEY);
+        if (!raw)
+            return prefs;
+        const value = JSON.parse(raw);
+        prefs.dismissed = value.dismissed === true;
+        prefs.readAloud = value.readAloud === true;
+        prefs.handsFree = value.handsFree === true;
+        prefs.sendOnPause = value.sendOnPause === true;
+    }
+    catch {
+        // Unreadable or unavailable: the defaults.
+    }
+    return prefs;
+}
+export function saveAiPrefs(storage, prefs) {
+    try {
+        storage?.setItem(AI_PREFS_KEY, JSON.stringify(prefs));
+    }
+    catch {
+        // Not saved; the choice still holds for this visit.
+    }
+}
+/**
+ * The one store behind the sidebar icons, the AI models page, the first-visit
+ * form and the assistant: it owns the language-model session, the voice-typing
+ * session and the read-aloud choice, and reads them as three capabilities.
+ */
+export class AiState {
+    session;
+    voice;
+    prefs = $state({
+        dismissed: false,
+        readAloud: false,
+        handsFree: false,
+        sendOnPause: false,
+    });
+    /** True once the browser has read its saved state (nothing before). */
+    hydrated = $state(false);
+    /** The first-visit setup form is showing. */
+    firstRun = $state(false);
+    /**
+     * A reply is being read aloud, from the moment it is queued until the last
+     * utterance ends, errors or is cancelled. Hands-free listening pauses
+     * while this is true, so the microphone does not transcribe the voice.
+     */
+    speaking = $state(false);
+    /** Where the model runs, from `planner.config.json` or the `inference` prop. */
+    inference = $state(DEFAULT_INFERENCE);
+    /** Set when the config was unusable and `browser` is used instead. */
+    notice = $state('');
+    /** The visitor's own endpoint (byo mode only). */
+    byo = $state(null);
+    /** Utterances queued and not yet ended; `speaking` is `pending > 0`. */
+    pending = 0;
+    /** Bumped on cancel so late events from cancelled utterances are ignored. */
+    generation = 0;
+    options;
+    /** The config is still being fetched: leave the first-run decision to `configure`. */
+    pendingConfig = false;
+    builtAtHydrate = false;
+    synth;
+    mic;
+    constructor(options) {
+        this.options = options;
+        this.session = new AssistantSession({
+            ...options.session,
+            storage: options.storage,
+            onReply: (text) => this.speak(text),
+        });
+        this.voice = new VoiceSession({
+            ...options.voice,
+            storage: options.storage,
+        });
+        this.synth =
+            options.synth !== undefined
+                ? options.synth
+                : typeof speechSynthesis !== 'undefined'
+                    ? speechSynthesis
+                    : null;
+        this.mic =
+            options.mic ??
+                (typeof navigator !== 'undefined' && !!navigator.mediaDevices);
+    }
+    /**
+     * Read the saved choices, probe the browser's speech, and decide whether
+     * this is a first visit. Call once, in the browser, after the cookbook.
+     */
+    hydrate(built) {
+        if (this.hydrated)
+            return;
+        this.prefs = loadAiPrefs(this.options.storage);
+        this.hydrated = true;
+        this.builtAtHydrate = built;
+        if (!this.pendingConfig)
+            this.decideFirstRun();
+        void this.voice.init();
+    }
+    /** The layout is fetching `planner.config.json`; `configure` follows. */
+    awaitConfig() {
+        this.pendingConfig = true;
+    }
+    /**
+     * Apply the inference config. `host` is ready at once (nothing to download);
+     * `byo` is ready once the visitor has connected an endpoint on the AI page;
+     * `browser` is today's WebLLM. An unusable config arrives as `browser` with
+     * a `notice`.
+     */
+    configure(result) {
+        const { config, notice } = result;
+        this.pendingConfig = false;
+        this.inference = config;
+        this.notice = notice ?? '';
+        this.session.setMode(config.mode);
+        this.byo = null;
+        if (config.mode === 'host' && config.host) {
+            const { controller, store, settings, theme } = this.options.session;
+            const plan = controller ?? createSliceController({ store, settings, theme });
+            this.session.useRemote(createHostChat({
+                endpoint: config.host.endpoint,
+                snapshot: () => plan.snapshot(),
+                fetch: this.options.fetch,
+            }), 'Server');
+        }
+        else if (config.mode === 'byo') {
+            this.byo = new ByoModel({
+                storage: this.options.storage,
+                presets: config.byo?.presets,
+                fetch: this.options.fetch,
+                onChange: () => this.syncByo(),
+            });
+            this.syncByo();
+        }
+        if (this.hydrated)
+            this.decideFirstRun();
+    }
+    syncByo() {
+        const byo = this.byo;
+        if (!byo)
+            return;
+        this.session.useRemote(byo.active ? byo.chat() : null, byo.model);
+    }
+    decideFirstRun() {
+        // A host's server needs nothing set up, so the form has nothing to ask for.
+        this.firstRun =
+            this.inference.mode !== 'host' &&
+                needsFirstRunSetup({
+                    thinkDownloaded: this.session.prefs.consented.length > 0 ||
+                        this.session.status === 'ready',
+                    hearDownloaded: loadVoiceConsent(this.options.storage),
+                    readAloud: this.prefs.readAloud,
+                    dismissed: this.prefs.dismissed,
+                    built: this.builtAtHydrate,
+                });
+    }
+    /** Before hydration every capability reads as not set up, as on the server. */
+    get capabilities() {
+        const model = getModel(this.session.prefs.modelId);
+        const ready = this.hydrated;
+        return deriveCapabilities({
+            think: {
+                status: ready ? this.session.status : 'idle',
+                model: model ? shortLabel(model) : 'model',
+                progress: this.session.progress.progress,
+                downloaded: ready && this.session.prefs.consented.length > 0,
+                mode: this.session.mode,
+                remote: this.session.remoteLabel,
+            },
+            hear: {
+                status: ready ? this.voice.status : 'checking',
+                mic: !ready || this.mic,
+            },
+            speak: {
+                supported: !ready || this.synth !== null,
+                readAloud: ready && this.prefs.readAloud,
+            },
+        });
+    }
+    /** One sentence on where what the visitor types goes, for the AI page. */
+    get privacyNote() {
+        if (this.inference.mode === 'host') {
+            return "Your messages and a short summary of your plan go to this site's server. Voice typing and reading aloud stay on this device.";
+        }
+        if (this.inference.mode === 'byo') {
+            return 'Your messages and a short summary of your plan go to the model endpoint you choose, and nowhere else. Voice typing and reading aloud stay on this device.';
+        }
+        return 'Everything runs on this device. Nothing you type or say leaves the page.';
+    }
+    get speakSupported() {
+        return this.synth !== null;
+    }
+    /** "Continue": leave the first-visit form for now. */
+    continueFirstRun() {
+        this.firstRun = false;
+    }
+    /** "I don't need AI": remembered, so the form never leads again. */
+    dismissFirstRun() {
+        this.firstRun = false;
+        this.setPrefs({ ...this.prefs, dismissed: true });
+    }
+    setReadAloud(on) {
+        if (on && !this.synth)
+            return;
+        if (!on)
+            this.cancelSpeech();
+        this.setPrefs({ ...this.prefs, readAloud: on });
+    }
+    /** "Start when I talk, stop when I pause": remembered across visits. */
+    setHandsFree(on) {
+        this.setPrefs({ ...this.prefs, handsFree: on });
+    }
+    /** "Send when I stop talking": remembered across visits. */
+    setSendOnPause(on) {
+        this.setPrefs({ ...this.prefs, sendOnPause: on });
+    }
+    /** Hands-free is active and the visitor asked for a send on each pause. */
+    get sendOnPauseActive() {
+        return this.handsFreeActive && this.prefs.sendOnPause;
+    }
+    /**
+     * Hands-free dictation is on and possible: the downloaded model is what
+     * writes the sentences down (the browser's own recogniser cannot).
+     */
+    get handsFreeActive() {
+        return this.prefs.handsFree && this.voice.status === 'ready';
+    }
+    /**
+     * Speak a reply when the visitor switched read-aloud on. Paragraphs are
+     * separate utterances; `speaking` stays true until the last one ends.
+     */
+    speak(text) {
+        if (!this.prefs.readAloud || !this.synth || !text.trim())
+            return;
+        this.cancelSpeech();
+        const chunks = text
+            .split(/\n{2,}/)
+            .map((chunk) => chunk.trim())
+            .filter(Boolean);
+        const generation = this.generation;
+        this.pending = chunks.length;
+        this.speaking = true;
+        const settle = () => {
+            if (generation !== this.generation)
+                return;
+            this.pending = Math.max(0, this.pending - 1);
+            if (this.pending === 0)
+                this.speaking = false;
+        };
+        for (const chunk of chunks) {
+            const utterance = new SpeechSynthesisUtterance(chunk);
+            utterance.onend = settle;
+            utterance.onerror = settle;
+            this.synth.speak(utterance);
+        }
+    }
+    /**
+     * Stop talking now (typing, the microphone, read-aloud switched off).
+     * Clears `speaking` at once rather than waiting for the browser's events.
+     */
+    cancelSpeech() {
+        this.generation += 1;
+        this.pending = 0;
+        this.speaking = false;
+        this.synth?.cancel();
+    }
+    setPrefs(prefs) {
+        this.prefs = prefs;
+        saveAiPrefs(this.options.storage, prefs);
+    }
+}

package/dist/ai/status.d.ts

@@ -0,0 +1,67 @@
+import type { SessionStatus } from '../assistant/session.svelte.ts';
+import type { VoiceStatus } from '../assistant/voice.svelte.ts';
+import type { InferenceMode } from '../inference/config.ts';
+/**
+ * What the three capabilities look like to the visitor, derived from the
+ * session states. Pure, so the sidebar icons, the setup page and the tests
+ * share one reading.
+ *
+ * - ready: set up and working right now
+ * - available: can be set up (or switched on) here
+ * - off: this browser cannot do it
+ */
+export type CapabilityId = 'think' | 'hear' | 'speak';
+export type CapabilityState = 'ready' | 'available' | 'off';
+export interface CapabilitySummary {
+    id: CapabilityId;
+    /** "Think", "Hear", "Speak". */
+    name: string;
+    state: CapabilityState;
+    /** The accessible name and tooltip: "Think: Qwen3 1.7B ready". */
+    label: string;
+    /** Where it runs: "In browser", "Server", "Your model: gpt-4o-mini". Think only. */
+    where?: string;
+}
+export interface CapabilityInput {
+    think: {
+        status: SessionStatus;
+        /** The selected model's short name. */
+        model: string;
+        /** Loading progress, 0 to 1. */
+        progress: number;
+        /** A model has been downloaded before. */
+        downloaded: boolean;
+        /** Where the model runs; default `browser`. */
+        mode?: InferenceMode;
+        /** Remote modes: the model's name, e.g. `gpt-4o-mini`. */
+        remote?: string;
+    };
+    hear: {
+        status: VoiceStatus;
+        /** The browser has a microphone API at all. */
+        mic: boolean;
+    };
+    speak: {
+        /** The browser has speech synthesis. */
+        supported: boolean;
+        readAloud: boolean;
+    };
+}
+export declare function deriveCapabilities(input: CapabilityInput): CapabilitySummary[];
+/** What the visitor has set up, for the first-visit decision. */
+export interface SetupFacts {
+    /** They downloaded a language model before. */
+    thinkDownloaded: boolean;
+    /** They downloaded the speech model before. */
+    hearDownloaded: boolean;
+    readAloud: boolean;
+    /** They chose "I don't need AI". */
+    dismissed: boolean;
+    /** They already built something (recipes or features). */
+    built: boolean;
+}
+/**
+ * Whether the first thing shown is the AI setup form: only for a visitor who
+ * has set nothing up, has not said they do not need AI, and has nothing built.
+ */
+export declare function needsFirstRunSetup(facts: SetupFacts): boolean;

package/dist/ai/status.js

@@ -0,0 +1,117 @@
+export function deriveCapabilities(input) {
+    return [
+        thinkSummary(input.think),
+        hearSummary(input.hear),
+        speakSummary(input.speak),
+    ];
+}
+function thinkSummary(t) {
+    const base = { id: 'think', name: 'Think' };
+    if (t.mode === 'host') {
+        return {
+            ...base,
+            state: t.status === 'ready' ? 'ready' : 'available',
+            label: 'Think: Server',
+            where: 'Server',
+        };
+    }
+    if (t.mode === 'byo') {
+        const where = t.remote ? `Your model: ${t.remote}` : '';
+        return t.status === 'ready' && t.remote
+            ? { ...base, state: 'ready', label: `Think: ${where}`, where }
+            : {
+                ...base,
+                state: 'available',
+                label: 'Think: your own model not connected',
+                where: 'Your model',
+            };
+    }
+    const browser = thinkInBrowser(t);
+    return { ...browser, where: 'In browser' };
+}
+function thinkInBrowser(t) {
+    const base = { id: 'think', name: 'Think' };
+    if (t.status === 'unsupported') {
+        return {
+            ...base,
+            state: 'off',
+            label: 'Think: unavailable, this browser has no WebGPU',
+        };
+    }
+    if (t.status === 'ready') {
+        return { ...base, state: 'ready', label: `Think: ${t.model} ready` };
+    }
+    if (t.status === 'loading') {
+        return {
+            ...base,
+            state: 'available',
+            label: `Think: ${t.model} loading, ${Math.round(t.progress * 100)}%`,
+        };
+    }
+    return {
+        ...base,
+        state: 'available',
+        label: t.downloaded
+            ? `Think: ${t.model} downloaded, not loaded`
+            : 'Think: not set up',
+    };
+}
+function hearSummary(h) {
+    const base = { id: 'hear', name: 'Hear' };
+    if (!h.mic) {
+        return {
+            ...base,
+            state: 'off',
+            label: 'Hear: unavailable, this browser has no microphone access',
+        };
+    }
+    if (h.status === 'browser') {
+        return {
+            ...base,
+            state: 'ready',
+            label: 'Hear: voice typing ready, using your browser',
+        };
+    }
+    if (h.status === 'ready') {
+        return {
+            ...base,
+            state: 'ready',
+            label: 'Hear: voice typing ready, using the downloaded model',
+        };
+    }
+    if (h.status === 'downloading') {
+        return {
+            ...base,
+            state: 'available',
+            label: 'Hear: downloading the speech model',
+        };
+    }
+    return { ...base, state: 'available', label: 'Hear: not set up' };
+}
+function speakSummary(s) {
+    const base = { id: 'speak', name: 'Speak' };
+    if (!s.supported) {
+        return {
+            ...base,
+            state: 'off',
+            label: 'Speak: unavailable, this browser has no speech synthesis',
+        };
+    }
+    if (s.readAloud) {
+        return {
+            ...base,
+            state: 'ready',
+            label: 'Speak: reading replies aloud with browser voices',
+        };
+    }
+    return { ...base, state: 'available', label: 'Speak: not switched on' };
+}
+/**
+ * Whether the first thing shown is the AI setup form: only for a visitor who
+ * has set nothing up, has not said they do not need AI, and has nothing built.
+ */
+export function needsFirstRunSetup(facts) {
+    if (facts.dismissed || facts.built)
+        return false;
+    return !(facts.thinkDownloaded || facts.hearDownloaded || facts.readAloud);
+}

package/dist/assets/smrt-mark.svg

@@ -0,0 +1,38 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 128 128" role="img">
+  <defs>
+    <linearGradient id="flame" x1="26" y1="16" x2="101" y2="112" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#f05b2b"/>
+      <stop offset="1" stop-color="#c9381e"/>
+    </linearGradient>
+    <linearGradient id="heat" x1="51" y1="49" x2="72" y2="111" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#ffd33d"/>
+      <stop offset="1" stop-color="#f2a817"/>
+    </linearGradient>
+  </defs>
+  <path
+    fill="url(#flame)"
+    d="M64 5c-3 18-15 26-13 43-9-5-13-13-13-22C20 43 15 62 22 82c7 22 23 37 42 41 22-4 39-21 43-43 3-17-3-32-18-45 2 11 0 18-6 25C84 36 75 19 64 5Z"
+  />
+  <path
+    fill="url(#heat)"
+    d="M64 45c-2 15-14 22-13 38-5-4-8-9-9-15-7 10-8 20-4 30 5 12 14 20 26 23 13-3 23-12 27-25 3-11 0-20-8-29 0 7-2 12-6 16 1-16-5-27-13-38Z"
+  />
+  <!--
+    The glasses render as two stacked stroke groups: a pale warm casing under
+    a dark warm-charcoal stroke. The casing keeps the dark strokes legible
+    where they leave the flame body (temple tips, lower rims) on dark
+    backgrounds, and reads as a rim light against the flame on light ones.
+  -->
+  <g fill="none" stroke="#ffe3ae" stroke-opacity="0.85" stroke-linecap="round" stroke-linejoin="round">
+    <path stroke-width="14" d="M7 63c12-4 27-5 43-1M78 62c16-4 31-3 43 1"/>
+    <rect x="12" y="58" width="46" height="35" rx="13" stroke-width="14"/>
+    <rect x="70" y="58" width="46" height="35" rx="13" stroke-width="14"/>
+    <path stroke-width="13" d="M57 66c5-4 9-4 14 0"/>
+  </g>
+  <g fill="none" stroke="#33221b" stroke-linecap="round" stroke-linejoin="round">
+    <path stroke-width="8" d="M7 63c12-4 27-5 43-1M78 62c16-4 31-3 43 1"/>
+    <rect x="12" y="58" width="46" height="35" rx="13" stroke-width="8"/>
+    <rect x="70" y="58" width="46" height="35" rx="13" stroke-width="8"/>
+    <path stroke-width="7" d="M57 66c5-4 9-4 14 0"/>
+  </g>
+</svg>

package/dist/assistant/change.d.ts

@@ -0,0 +1,101 @@
+import type { Recipe } from '../recipes/types.ts';
+import type { AppSettings } from '../settings/app-settings.ts';
+import { type ColorSchemeSetting, type ThemeSetting } from '../theme/theme.ts';
+/** Settings as the model states them: tax in percent. All optional. */
+export interface SettingsPatch {
+    currency?: string;
+    /** Percent, 0 to 100. */
+    taxRate?: number;
+    paymentTerms?: string;
+}
+/**
+ * A look as the model states it: a preset, or a brand colour (hex), and
+ * optionally light or dark. Tokens only; there is no way to ask for CSS.
+ */
+export interface ThemePatch {
+    preset?: string;
+    /** `#rrggbb`. */
+    primary?: string;
+    colorScheme?: ColorSchemeSetting;
+}
+/** Longest payment terms the assistant will write. */
+export declare const MAX_TERMS_LENGTH = 40;
+/** Longest reply the schema allows; bounds a model that starts to loop. */
+export declare const MAX_REPLY_LENGTH = 200;
+/** Shown when the model's answer cannot be read; never the raw output. */
+export declare const FALLBACK_REPLY = "Sorry, say that again?";
+/**
+ * What the model returns each turn: a reply, recipe ids to add or remove, an
+ * optional cookbook to offer (never applied without a click) and optional
+ * settings to change.
+ */
+export interface AssistantChange {
+    reply: string;
+    add: string[];
+    remove: string[];
+    cookbook: string | null;
+    settings: SettingsPatch;
+    theme: ThemePatch;
+    /**
+     * Command calls a trusted host server asked for (`parseChange` with
+     * `commands: true`); the controller validates each one. Absent otherwise.
+     */
+    commands?: {
+        name: string;
+        input: unknown;
+    }[];
+}
+/** Most command calls one reply may carry. */
+export declare const MAX_COMMANDS = 8;
+/** The slice of the cookbook store that holds the app theme. */
+export interface ThemeStore {
+    read(): ThemeSetting | undefined;
+    write(theme: ThemeSetting | undefined): void;
+}
+/** The slice of the cookbook store that holds the app settings. */
+export interface SettingsStore {
+    read(): AppSettings;
+    write(settings: AppSettings): void;
+}
+/** The slice of the recipe store the assistant drives (the Planner cards use the same). */
+export interface RecipeStore {
+    readonly ids: readonly string[];
+    add(...ids: string[]): void;
+    remove(...ids: string[]): void;
+}
+/** The result of applying a change, after `requires` and `requiresAny` ran. */
+export interface AppliedChange {
+    /** Newly on, including recipes pulled in because another needs them. */
+    added: string[];
+    /** Newly off. */
+    removed: string[];
+    /** Asked to remove, but another added recipe needs them. */
+    kept: string[];
+}
+/**
+ * The JSON Schema for one turn. `add` and `remove` are enums of recipe ids,
+ * so grammar-constrained decoding cannot produce an id that does not exist.
+ */
+export declare function buildResponseSchema(recipes: readonly Pick<Recipe, 'id'>[], cookbooks?: readonly {
+    id: string;
+}[], withSettings?: boolean, withTheme?: boolean): Record<string, unknown>;
+/** Keep only valid settings: circulating currency, tax 0-100, short terms. */
+export declare function parseSettings(value: unknown): SettingsPatch;
+/** Keep only a known preset, a hex colour and light or dark. */
+export declare function parseThemePatch(value: unknown): ThemePatch;
+/** Remove Qwen3-style thinking, including a block cut off before it closed. */
+export declare function stripThinking(raw: string): string;
+/**
+ * Read a model reply. Thinking tags are dropped. Malformed JSON still yields
+ * its `reply` text when one can be found, otherwise a short fallback: raw model
+ * output is never shown. Prose with no JSON in it is kept as the reply.
+ * Unknown ids are dropped, an id that is both added and removed is ignored,
+ * and repeats collapse.
+ */
+export declare function parseChange(input: string, recipes: readonly Pick<Recipe, 'id'>[], cookbooks?: readonly {
+    id: string;
+}[], options?: {
+    commands?: boolean;
+}): AssistantChange;
+/** A sentence for the chat saying what changed, by recipe label. */
+export declare function describeChange(applied: AppliedChange, recipes: readonly Pick<Recipe, 'id' | 'label'>[]): string;