logisheets-logician 1.11.0

package/dist/craft-interactions-core.js

@@ -0,0 +1,33 @@
+/**
+ * A {@link CraftInteractionsApi} implementation backed directly by
+ * logisheets-core's craft-interactions singletons.
+ *
+ * Use this when logician runs IN-PROCESS with the engine logic — i.e. a Node
+ * runtime (logisheets-runtime), or any non-iframe host. The browser/Watson
+ * path still uses the window-global adapter, because a craft iframe has its
+ * own module instances and must bridge to the *host page's* singletons across
+ * the iframe boundary; importing core there would yield a fresh, isolated
+ * store. In-process (Node), there is no boundary, so delegating straight to
+ * core is correct and removes the window dependency entirely.
+ */
+import { registerRadioBinding, clearRadioBindings, getRadioSelection, registerMultiSelectBinding, setMultiSelectMax, clearMultiSelectBindings, getMultiSelectSelections, registerPointAllocator, setPointPool, clearPointAllocators, getPointPool, getPointAllocations, registerPercentAllocator, clearPercentAllocators, registerNumberSlider, clearNumberSliders, } from 'logisheets-core';
+export function createCoreCraftInteractions() {
+    return {
+        registerRadio: (b) => registerRadioBinding({ type: 'radio', ...b }),
+        registerMultiSelect: (b) => registerMultiSelectBinding({ type: 'multiSelect', ...b }),
+        setMultiSelectMax: (groupId, max) => setMultiSelectMax(groupId, max),
+        registerPointAllocator: (b) => registerPointAllocator({ type: 'pointAllocator', ...b }),
+        setPointPool: (groupId, total) => setPointPool(groupId, total),
+        registerPercentAllocator: (b) => registerPercentAllocator({ type: 'percentAllocator', ...b }),
+        registerNumberSlider: (b) => registerNumberSlider({ type: 'numberSlider', ...b }),
+        clearRadios: (groupId) => clearRadioBindings(groupId),
+        clearMultiSelects: (groupId) => clearMultiSelectBindings(groupId),
+        clearPointAllocators: (groupId) => clearPointAllocators(groupId),
+        clearPercentAllocators: (groupId) => clearPercentAllocators(groupId),
+        clearNumberSliders: (groupId) => clearNumberSliders(groupId),
+        getRadioSelection: (groupId) => getRadioSelection(groupId),
+        getMultiSelectSelections: (groupId) => getMultiSelectSelections(groupId),
+        getPointPool: (groupId) => getPointPool(groupId),
+        getPointAllocations: (groupId) => getPointAllocations(groupId),
+    };
+}

package/dist/crafts/manifest.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The craft capability manifest — the wire contract Watson reads to discover a
+ * craft's skill and invoke its tools. Produced by the `craftsmith` CLI as
+ * `dist/manifest.json`. Mirrored here (rather than imported from `craftsmith`)
+ * so `logician` stays free of any build-tooling dependency — the same way the
+ * `Tool` / JSONSchema shapes are self-contained.
+ *
+ * Keep in sync with packages/craftsmith/src/manifest.ts.
+ */
+import type { JSONSchema, ConfirmationPolicy } from '../tool.js';
+export type MutatesPolicy = 'none' | 'temp' | true;
+export interface ManifestTool {
+    name: string;
+    description: string;
+    inputSchema: JSONSchema;
+    outputSchema?: JSONSchema;
+    /** Parameter names in call order: fn(ctx, ...paramOrder.map(p => args[p])). */
+    paramOrder: string[];
+    /** Module the function lives in, relative to the craft package root. */
+    entry: string;
+    /** Exported binding name = the dispatch key. */
+    export: string;
+    mutates: MutatesPolicy;
+    confirmation: ConfirmationPolicy;
+}
+export interface ManifestSkill {
+    description: string;
+    guidance?: string;
+}
+export interface CraftManifest {
+    schemaVersion: 1;
+    craftId: string;
+    version: string;
+    label: string;
+    url?: string;
+    rtJs?: string;
+    skill?: ManifestSkill;
+    tools?: ManifestTool[];
+}

package/dist/crafts/manifest.js

@@ -0,0 +1,10 @@
+/**
+ * The craft capability manifest — the wire contract Watson reads to discover a
+ * craft's skill and invoke its tools. Produced by the `craftsmith` CLI as
+ * `dist/manifest.json`. Mirrored here (rather than imported from `craftsmith`)
+ * so `logician` stays free of any build-tooling dependency — the same way the
+ * `Tool` / JSONSchema shapes are self-contained.
+ *
+ * Keep in sync with packages/craftsmith/src/manifest.ts.
+ */
+export {};

package/dist/crafts/skill-tools.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The bridge between Watson and installed crafts.
+ *
+ * Two meta-tools implement progressive discovery (keeps the LLM tool list
+ * bounded as the plugin ecosystem grows):
+ *
+ *   skills__discover  →  list installed crafts + their "when to use me" line
+ *   skills__use       →  load one craft's tools into the live registry so the
+ *                        model can call them on the next turn
+ *
+ * A loaded craft tool dispatches straight to the craft module's named export,
+ * passing the same ToolContext the built-in tools receive — which is exactly the
+ * craft's `ctx` (workbook / signal / confirm / log). One function, three callers.
+ */
+import type { CraftStateAccess, Tool, ToolRegistry } from '../tool.js';
+import type { InstalledCraftStore } from './store.js';
+import type { ManifestTool } from './manifest.js';
+/** Host capability: build a craftState accessor scoped to one craft. */
+export type CraftStateProvider = (craftId: string) => CraftStateAccess;
+export interface CraftSkillToolsOptions {
+    /** Wires ctx.craftState for dispatched craft tools, scoped per craft. */
+    craftState?: CraftStateProvider;
+}
+/** Build a live Tool that dispatches to a craft module's exported function. */
+export declare function craftToolFromManifest(craftId: string, mt: ManifestTool, store: InstalledCraftStore, craftState?: CraftStateProvider): Tool;
+/**
+ * The two discovery/loading meta-tools. Register these into the same registry
+ * the Agent uses; `skills__use` registers craft tools into it on demand, and the
+ * agent loop re-lists tools every request so they surface immediately.
+ */
+export declare function makeCraftSkillTools(store: InstalledCraftStore, registry: ToolRegistry, opts?: CraftSkillToolsOptions): Tool[];
+/** Convenience: build and register the two meta-tools into `registry`. */
+export declare function installCraftSkillTools(store: InstalledCraftStore, registry: ToolRegistry, opts?: CraftSkillToolsOptions): void;

package/dist/crafts/skill-tools.js

@@ -0,0 +1,146 @@
+/**
+ * The bridge between Watson and installed crafts.
+ *
+ * Two meta-tools implement progressive discovery (keeps the LLM tool list
+ * bounded as the plugin ecosystem grows):
+ *
+ *   skills__discover  →  list installed crafts + their "when to use me" line
+ *   skills__use       →  load one craft's tools into the live registry so the
+ *                        model can call them on the next turn
+ *
+ * A loaded craft tool dispatches straight to the craft module's named export,
+ * passing the same ToolContext the built-in tools receive — which is exactly the
+ * craft's `ctx` (workbook / signal / confirm / log). One function, three callers.
+ */
+import { toolId } from '../tool.js';
+/** Anthropic tool names allow [A-Za-z0-9_-] only — no dots. */
+function sanitizeNamespace(craftId) {
+    return craftId.replace(/[^a-zA-Z0-9_-]/g, '_');
+}
+/** Build a live Tool that dispatches to a craft module's exported function. */
+export function craftToolFromManifest(craftId, mt, store, craftState) {
+    return {
+        namespace: sanitizeNamespace(craftId),
+        name: mt.name,
+        description: mt.description,
+        inputSchema: mt.inputSchema,
+        mutates: mt.mutates !== 'none',
+        confirmation: mt.confirmation,
+        handler: async (input, ctx) => {
+            const mod = await store.load(craftId, mt.entry);
+            const fn = mod[mt.export];
+            if (typeof fn !== 'function')
+                throw new Error(`craft "${craftId}" has no exported function "${mt.export}" in ${mt.entry}`);
+            const args = mt.paramOrder.map((p) => input === null || input === void 0 ? void 0 : input[p]);
+            // Scope craftState to THIS craft before handing the ctx to it.
+            const craftCtx = craftState
+                ? { ...ctx, craftState: craftState(craftId) }
+                : ctx;
+            // ctx is the craft's first (host-injected) parameter.
+            const data = await fn(craftCtx, ...args);
+            return { data: data !== null && data !== void 0 ? data : null };
+        },
+    };
+}
+const DISCOVER_DESCRIPTION = 'List installed crafts and what each is good at. Call this FIRST when a task ' +
+    'might be handled by a craft/plugin, then call skills__use to load the ' +
+    'chosen craft\'s tools. Optional `query` filters by keyword.';
+const USE_DESCRIPTION = "Load an installed craft's tools into this conversation so you can call them. " +
+    'Pass the `craftId` from skills__discover. Returns the loaded tool names and ' +
+    "the craft's usage guidance; the tools become callable on your next step.";
+/**
+ * The two discovery/loading meta-tools. Register these into the same registry
+ * the Agent uses; `skills__use` registers craft tools into it on demand, and the
+ * agent loop re-lists tools every request so they surface immediately.
+ */
+export function makeCraftSkillTools(store, registry, opts = {}) {
+    const discover = {
+        namespace: 'skills',
+        name: 'discover',
+        description: DISCOVER_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Optional keyword to filter crafts by.',
+                },
+            },
+        },
+        mutates: false,
+        confirmation: 'never',
+        handler: async (input) => {
+            var _a;
+            const rows = await store.list();
+            const q = (_a = input === null || input === void 0 ? void 0 : input.query) === null || _a === void 0 ? void 0 : _a.toString().toLowerCase();
+            const filtered = q
+                ? rows.filter((s) => {
+                    var _a;
+                    return `${s.label} ${s.craftId} ${(_a = s.description) !== null && _a !== void 0 ? _a : ''}`
+                        .toLowerCase()
+                        .includes(q);
+                })
+                : rows;
+            return {
+                data: filtered.map((s) => {
+                    var _a;
+                    return ({
+                        craftId: s.craftId,
+                        label: s.label,
+                        when: (_a = s.description) !== null && _a !== void 0 ? _a : null,
+                    });
+                }),
+                display: `${filtered.length} craft(s) available`,
+            };
+        },
+    };
+    const use = {
+        namespace: 'skills',
+        name: 'use',
+        description: USE_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                craftId: {
+                    type: 'string',
+                    description: 'The craft to load, from skills__discover.',
+                },
+            },
+            required: ['craftId'],
+        },
+        mutates: false,
+        confirmation: 'never',
+        handler: async (input) => {
+            var _a, _b, _c, _d;
+            const craftId = input === null || input === void 0 ? void 0 : input.craftId;
+            if (!craftId)
+                throw new Error('craftId is required');
+            const manifest = await store.get(craftId);
+            if (!manifest)
+                throw new Error(`craft "${craftId}" is not installed`);
+            const tools = (_a = manifest.tools) !== null && _a !== void 0 ? _a : [];
+            const loaded = [];
+            for (const mt of tools) {
+                const tool = craftToolFromManifest(craftId, mt, store, opts.craftState);
+                if (!registry.get(toolId(tool)))
+                    registry.register(tool);
+                loaded.push(toolId(tool));
+            }
+            return {
+                data: {
+                    craftId,
+                    label: manifest.label,
+                    guidance: (_c = (_b = manifest.skill) === null || _b === void 0 ? void 0 : _b.guidance) !== null && _c !== void 0 ? _c : null,
+                    tools: loaded,
+                },
+                display: `Loaded ${loaded.length} tool(s) from "${manifest.label}"` +
+                    (((_d = manifest.skill) === null || _d === void 0 ? void 0 : _d.guidance) ? ' — see guidance' : ''),
+            };
+        },
+    };
+    return [discover, use];
+}
+/** Convenience: build and register the two meta-tools into `registry`. */
+export function installCraftSkillTools(store, registry, opts = {}) {
+    registry.registerMany(makeCraftSkillTools(store, registry, opts));
+}

package/dist/crafts/store.d.ts

@@ -0,0 +1,47 @@
+/**
+ * InstalledCraftStore — the host capability that lets Watson enumerate and load
+ * installed crafts, VSCode-extension style. The store is platform-specific (web:
+ * a DB / IndexedDB + fetch of the built package; desktop: an app-data dir), but
+ * this interface is host-neutral so the discover/use tools work everywhere.
+ *
+ * See docs/craft/craftsmith.md → "Distribution, installation & enumeration".
+ */
+import type { CraftManifest } from './manifest.js';
+/** Lightweight row for the discovery list (no tool detail). */
+export interface InstalledCraftSummary {
+    craftId: string;
+    label: string;
+    /** The skill's "when to use me" description, if the craft exposes tools. */
+    description?: string;
+}
+export interface InstalledCraftStore {
+    /** Enumerate installed crafts — what `discover_skills` iterates. */
+    list(): Promise<InstalledCraftSummary[]>;
+    /** Full manifest for one craft, or undefined if not installed. */
+    get(craftId: string): Promise<CraftManifest | undefined>;
+    /**
+     * Import a craft module by its manifest-relative entry (e.g. "tools.js") and
+     * return its exports. On web this is a dynamic `import()` of the installed
+     * package's URL; on desktop a file import. Implementations should cache.
+     */
+    load(craftId: string, entry: string): Promise<Record<string, unknown>>;
+}
+/**
+ * Merge several stores behind one InstalledCraftStore. This is how crafts from
+ * different sources coexist: today a single WebCraftStore over the crafts bundled
+ * into the app; once a marketplace/registry lands, add a DB-backed store for
+ * downloaded crafts — `new CompositeCraftStore([registryStore, bundledStore])` —
+ * and both show up in discovery, with no change to the discover/use tools.
+ *
+ * Precedence is by order: the FIRST store that knows a craftId owns it (so a
+ * downloaded craft can shadow a bundled one if its store is listed first). All
+ * of a craft's operations (get/load) route to its owning store.
+ */
+export declare class CompositeCraftStore implements InstalledCraftStore {
+    private readonly stores;
+    private owner;
+    constructor(stores: readonly InstalledCraftStore[]);
+    list(): Promise<InstalledCraftSummary[]>;
+    get(craftId: string): Promise<CraftManifest | undefined>;
+    load(craftId: string, entry: string): Promise<Record<string, unknown>>;
+}

package/dist/crafts/store.js

@@ -0,0 +1,69 @@
+/**
+ * InstalledCraftStore — the host capability that lets Watson enumerate and load
+ * installed crafts, VSCode-extension style. The store is platform-specific (web:
+ * a DB / IndexedDB + fetch of the built package; desktop: an app-data dir), but
+ * this interface is host-neutral so the discover/use tools work everywhere.
+ *
+ * See docs/craft/craftsmith.md → "Distribution, installation & enumeration".
+ */
+/**
+ * Merge several stores behind one InstalledCraftStore. This is how crafts from
+ * different sources coexist: today a single WebCraftStore over the crafts bundled
+ * into the app; once a marketplace/registry lands, add a DB-backed store for
+ * downloaded crafts — `new CompositeCraftStore([registryStore, bundledStore])` —
+ * and both show up in discovery, with no change to the discover/use tools.
+ *
+ * Precedence is by order: the FIRST store that knows a craftId owns it (so a
+ * downloaded craft can shadow a bundled one if its store is listed first). All
+ * of a craft's operations (get/load) route to its owning store.
+ */
+export class CompositeCraftStore {
+    constructor(stores) {
+        this.stores = stores;
+        this.owner = new Map();
+    }
+    async list() {
+        const seen = new Set();
+        const out = [];
+        for (const store of this.stores) {
+            let rows = [];
+            try {
+                rows = await store.list();
+            }
+            catch (_a) {
+                rows = []; // one source being down must not sink the rest
+            }
+            for (const row of rows) {
+                if (seen.has(row.craftId))
+                    continue;
+                seen.add(row.craftId);
+                this.owner.set(row.craftId, store);
+                out.push(row);
+            }
+        }
+        return out;
+    }
+    async get(craftId) {
+        const known = this.owner.get(craftId);
+        if (known)
+            return known.get(craftId);
+        for (const store of this.stores) {
+            const m = await store.get(craftId);
+            if (m) {
+                this.owner.set(craftId, store);
+                return m;
+            }
+        }
+        return undefined;
+    }
+    async load(craftId, entry) {
+        let store = this.owner.get(craftId);
+        if (!store) {
+            await this.get(craftId); // resolve ownership
+            store = this.owner.get(craftId);
+        }
+        if (!store)
+            throw new Error(`craft "${craftId}" not found in any installed source`);
+        return store.load(craftId, entry);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export * from './tool.js';
+export * from './craft-interactions-api.js';
+export * from './craft-interactions-core.js';
+export * from './tools/builder.js';
+export * from './tools/inspect.js';
+export * from './tools/edit.js';
+export * from './tools/cells.js';
+export * from './tools/format.js';
+export * from './tools/structure.js';
+export * from './tools/history.js';
+export * from './tools/comments.js';
+export * from './tools/block-ops.js';
+export * from './tools/links.js';
+export * from './tools/taxonomy.js';
+export * from './tools/craft-interactions.js';
+export * from './crafts/manifest.js';
+export * from './crafts/store.js';
+export * from './crafts/skill-tools.js';
+export * from './conversation.js';
+export * from './storage.js';
+export * from './projection.js';
+export * from './agent/loop.js';

package/dist/index.js

@@ -0,0 +1,22 @@
+export * from './tool.js';
+export * from './craft-interactions-api.js';
+export * from './craft-interactions-core.js';
+export * from './tools/builder.js';
+export * from './tools/inspect.js';
+export * from './tools/edit.js';
+export * from './tools/cells.js';
+export * from './tools/format.js';
+export * from './tools/structure.js';
+export * from './tools/history.js';
+export * from './tools/comments.js';
+export * from './tools/block-ops.js';
+export * from './tools/links.js';
+export * from './tools/taxonomy.js';
+export * from './tools/craft-interactions.js';
+export * from './crafts/manifest.js';
+export * from './crafts/store.js';
+export * from './crafts/skill-tools.js';
+export * from './conversation.js';
+export * from './storage.js';
+export * from './projection.js';
+export * from './agent/loop.js';