@ai-ecoverse/slicc-spectrum 1.1.0 → 1.3.0

package/dist/types/dummy/agent.d.ts

@@ -1,14 +1,32 @@
 import { Emitter } from '../model/emitter.js';
-import type { Agent, AgentEvents, AgentPort, Message } from '../model/types.js';
+import type { Agent, AgentEvents, AgentPort, FrozenCone, LickChannel, LickState, Message, Outgoing, UserMessage } from '../model/types.js';
 import type { Clock } from './clock.js';
 import { type Effects } from './script.js';
 export declare class DummyAgent extends Emitter<AgentEvents> implements AgentPort {
     #private;
-    constructor(agents: readonly Agent[], conversations: Record<string, readonly Message[]>, effects: Omit<Effects, 'agentId'>, clock: Clock);
+    constructor(agents: readonly Agent[], conversations: Record<string, readonly Message[]>, effects: Omit<Effects, 'agentId'>, clock: Clock, queues?: Record<string, readonly UserMessage[]>, frozen?: ReadonlyArray<{
+        cone: FrozenCone;
+        messages: readonly Message[];
+    }>);
     list(): readonly Agent[];
     active(): string;
     select(id: string): void;
     messages(agentId: string): readonly Message[];
-    send(agentId: string, text: string): Promise<void>;
+    queue(agentId: string): readonly UserMessage[];
+    busy(agentId: string): boolean;
+    suggestion(agentId: string): string | null;
+    unqueue(agentId: string, messageId: string): void;
+    send(agentId: string, input: string | Outgoing): Promise<void>;
     stop(agentId: string): void;
+    answer(agentId: string, questionId: string, answer: string): void;
+    resolveLick(agentId: string, messageId: string, state: Exclude<LickState, 'pending'>): void;
+    compact(agentId: string): void;
+    clear(agentId: string): void;
+    setModel(agentId: string, model: string): void;
+    createScoop(parentId: string, name: string): Agent;
+    lick(agentId: string, channel: LickChannel, title: string, text: string, body?: string): void;
+    frozen(): readonly FrozenCone[];
+    freeze(agentId: string): void;
+    thaw(id: string): Agent | null;
+    discard(id: string): void;
 }

package/dist/types/dummy/extras.d.ts

@@ -0,0 +1,8 @@
+import type { FrozenCone, Memory, Message, Sprinkle, TrayStatus } from '../model/types.js';
+export declare const frozen: Array<{
+    cone: FrozenCone;
+    messages: Message[];
+}>;
+export declare const memories: Memory[];
+export declare const sprinkles: Sprinkle[];
+export declare const tray: TrayStatus;

package/dist/types/dummy/fixtures.d.ts

@@ -1,4 +1,4 @@
-import type { Account, Agent, BrowserTab, Change, Message, ModelOption, Settings, TerminalInfo } from '../model/types.js';
+import type { Account, Agent, BrowserTab, Change, Message, ModelOption, Settings, TerminalInfo, UserMessage } from '../model/types.js';
 export declare const files: Record<string, string>;
 export declare const directories: string[];
 export declare const pending: Change[];
@@ -6,6 +6,7 @@ export declare const models: ModelOption[];
 export declare const defaults: Settings;
 export declare const accounts: Account[];
 export declare const agents: Agent[];
+export declare const queues: Record<string, UserMessage[]>;
 export declare const conversations: Record<string, Message[]>;
 export declare const tabs: BrowserTab[];
 export declare const terminals: TerminalInfo[];

package/dist/types/dummy/memory.d.ts

@@ -0,0 +1,9 @@
+import { Emitter } from '../model/emitter.js';
+import type { Memory, MemoryDraft, MemoryEvents, MemoryPort } from '../model/types.js';
+export declare class DummyMemory extends Emitter<MemoryEvents> implements MemoryPort {
+    #private;
+    constructor(memories: readonly Memory[]);
+    list(): readonly Memory[];
+    save(draft: MemoryDraft): Memory;
+    remove(id: string): void;
+}

package/dist/types/dummy/monitor.d.ts

@@ -0,0 +1,9 @@
+import { Emitter } from '../model/emitter.js';
+import type { MonitorEvents, MonitorPort, MonitorSnapshot, SliccModel } from '../model/types.js';
+export declare function wave(seed: number, length?: number): number[];
+export declare class DummyMonitor extends Emitter<MonitorEvents> implements MonitorPort {
+    #private;
+    constructor(model: Omit<SliccModel, 'monitor'>);
+    snapshot(): MonitorSnapshot;
+    resync(): void;
+}

package/dist/types/dummy/script.d.ts

@@ -1,10 +1,13 @@
-import type { BrowserPort, FilePort } from '../model/types.js';
+import type { Attachment, BrowserPort, FilePort, MessagePart } from '../model/types.js';
 export interface Effects {
     files: FilePort;
     browser: BrowserPort;
     agentId: string;
 }
 export type Step = {
+    type: 'part';
+    part: MessagePart;
+} | {
     type: 'thinking';
     text: string;
 } | {
@@ -20,4 +23,7 @@ export type Step = {
     ticks: number;
     effect?: (effects: Effects) => Promise<unknown> | unknown;
 };
-export declare function script(prompt: string): Step[];
+export declare function script(prompt: string, attachments?: readonly Attachment[]): {
+    steps: Step[];
+    suggestion: string;
+};

package/dist/types/dummy/showcase.d.ts

@@ -0,0 +1,6 @@
+import type { Agent, Message, UserMessage } from '../model/types.js';
+export declare function picture(label: string, from: string, to: string, width?: number, height?: number): string;
+export declare function tone(seconds?: number, frequency?: number, rate?: number): string;
+export declare const showcaseAgent: Agent;
+export declare function showcase(): Message[];
+export declare function showcaseQueue(): UserMessage[];

package/dist/types/dummy/sprinkles.d.ts

@@ -0,0 +1,9 @@
+import { Emitter } from '../model/emitter.js';
+import type { Sprinkle, SprinkleEvents, SprinklePort } from '../model/types.js';
+import type { DummyAgent } from './agent.js';
+export declare class DummySprinkles extends Emitter<SprinkleEvents> implements SprinklePort {
+    #private;
+    constructor(sprinkles: readonly Sprinkle[], agent: DummyAgent);
+    list(): readonly Sprinkle[];
+    send(id: string, payload: unknown): void;
+}

package/dist/types/dummy/tray.d.ts

@@ -0,0 +1,10 @@
+import { Emitter } from '../model/emitter.js';
+import type { TrayEvents, TrayPort, TrayStatus } from '../model/types.js';
+import type { Clock } from './clock.js';
+export declare class DummyTray extends Emitter<TrayEvents> implements TrayPort {
+    #private;
+    constructor(status: TrayStatus, clock: Clock);
+    status(): TrayStatus;
+    reconnect(): void;
+    disconnect(): void;
+}

package/dist/types/model/types.d.ts

@@ -12,7 +12,7 @@ export interface Agent {
     contextFill: number;
     unread: number;
 }
-export type ToolStatus = 'running' | 'done' | 'error';
+export type ToolStatus = 'running' | 'done' | 'error' | 'cancelled';
 export interface ToolCall {
     id: string;
     name: string;
@@ -21,6 +21,68 @@ export interface ToolCall {
     output: string;
     status: ToolStatus;
     paths: string[];
+    image?: string;
+}
+export type AttachmentKind = 'image' | 'text' | 'file' | 'secret';
+export interface Attachment {
+    id: string;
+    name: string;
+    kind: AttachmentKind;
+    mimeType: string;
+    size: number;
+    url?: string;
+    text?: string;
+    path?: string;
+    error?: string;
+}
+export type MediaKind = 'image' | 'video' | 'audio';
+export interface Media {
+    kind: MediaKind;
+    src: string;
+    alt: string;
+    poster?: string;
+    width?: number;
+    height?: number;
+}
+export type CardTone = 'neutral' | 'informative' | 'positive' | 'notice' | 'negative';
+export type ActionCard = {
+    variant: 'tool';
+    title: string;
+    badge: string;
+    status: string;
+    files: string[];
+    tone: CardTone;
+} | {
+    variant: 'pr';
+    number: number;
+    title: string;
+    branch: string;
+    checks: string;
+    additions: number;
+    deletions: number;
+    files: number;
+    tone: CardTone;
+} | {
+    variant: 'light';
+    title: string;
+    detail: string;
+    tone: CardTone;
+};
+export type QuestionKind = 'yes-no' | 'choice' | 'text' | 'number' | 'date' | 'email';
+export type QuestionState = 'open' | 'answered' | 'inert';
+export interface Question {
+    id: string;
+    kind: QuestionKind;
+    question: string;
+    options: string[];
+    state: QuestionState;
+    answer?: string;
+}
+export type DelegationKind = 'feed' | 'scoop' | 'drop' | 'sprinkle';
+export type ErrorAction = 'retry' | 'settings' | 'change-model' | 'login';
+export interface CheckItem {
+    text: string;
+    tone?: CardTone;
 }
 export type MessagePart = {
     type: 'text';
@@ -31,31 +93,105 @@ export type MessagePart = {
 } | {
     type: 'tool';
     tool: ToolCall;
+} | {
+    type: 'media';
+    items: Media[];
+} | {
+    type: 'card';
+    card: ActionCard;
+} | {
+    type: 'plan';
+    items: string[];
+} | {
+    type: 'check';
+    items: CheckItem[];
+} | {
+    type: 'diff';
+    path: string;
+    before: string | null;
+    after: string | null;
+} | {
+    type: 'question';
+    question: Question;
+} | {
+    type: 'delegation';
+    kind: DelegationKind;
+    scoop: string;
+    text: string;
+} | {
+    type: 'link';
+    url: string;
+    title: string;
+    description: string;
+} | {
+    type: 'error';
+    message: string;
+    action?: ErrorAction;
 };
+export type SendMode = 'send' | 'steer' | 'queue';
 export interface UserMessage {
     id: string;
     role: 'user';
     text: string;
     createdAt: number;
+    attachments?: Attachment[];
+    mode?: SendMode;
+    queued?: boolean;
+    from?: string;
+}
+export type AssistantStatus = 'streaming' | 'done' | 'stopped' | 'error';
+export interface Usage {
+    input: number;
+    output: number;
+    cost: number;
 }
-export type AssistantStatus = 'streaming' | 'done' | 'stopped';
 export interface AssistantMessage {
     id: string;
     role: 'assistant';
     parts: MessagePart[];
     status: AssistantStatus;
     createdAt: number;
+    model?: string;
+    usage?: Usage;
+}
+export type SystemKind = 'compaction' | 'error' | 'notice';
+export type CompactionState = 'summarizing' | 'summarized' | 'fallback' | 'discarded';
+export interface SystemMessage {
+    id: string;
+    role: 'system';
+    kind: SystemKind;
+    text: string;
+    createdAt: number;
+    title?: string;
+    trigger?: 'threshold' | 'overflow' | 'idle' | 'manual';
+    state?: CompactionState;
+    action?: ErrorAction;
 }
-export type EventKind = 'webhook' | 'cron' | 'scoop' | 'compaction' | 'error';
-export interface EventMessage {
+export interface ToolMessage {
     id: string;
-    role: 'event';
-    kind: EventKind;
+    role: 'tool';
+    tool: ToolCall;
+    createdAt: number;
+}
+export type LickChannel = 'webhook' | 'cron' | 'sprinkle' | 'fswatch' | 'session-reload' | 'navigate' | 'discovery' | 'upgrade' | 'workflow' | 'bash' | 'jshd' | 'preview' | 'cherry' | 'scoop-notify' | 'scoop-idle' | 'scoop-wait' | 'sudo-request';
+export type LickState = 'pending' | 'confirmed' | 'dismissed';
+export interface LickMessage {
+    id: string;
+    role: 'lick';
+    channel: LickChannel;
     title: string;
     text: string;
     createdAt: number;
+    body?: string;
+    count?: number;
+    state?: LickState;
+}
+export type Message = UserMessage | AssistantMessage | SystemMessage | ToolMessage | LickMessage;
+export interface Outgoing {
+    text: string;
+    attachments?: Attachment[];
+    mode?: SendMode;
 }
-export type Message = UserMessage | AssistantMessage | EventMessage;
 export interface AgentEvents {
     agents: readonly Agent[];
     active: string;
@@ -63,14 +199,38 @@ export interface AgentEvents {
         agentId: string;
         message: Message;
     };
+    messages: string;
+    frozen: readonly FrozenCone[];
 }
 export interface AgentPort extends Subscribable<AgentEvents> {
     list(): readonly Agent[];
     active(): string;
     select(id: string): void;
     messages(agentId: string): readonly Message[];
-    send(agentId: string, text: string): Promise<void>;
+    send(agentId: string, input: string | Outgoing): Promise<void>;
     stop(agentId: string): void;
+    busy(agentId: string): boolean;
+    queue(agentId: string): readonly UserMessage[];
+    unqueue(agentId: string, messageId: string): void;
+    suggestion(agentId: string): string | null;
+    answer(agentId: string, questionId: string, answer: string): void;
+    resolveLick(agentId: string, messageId: string, state: Exclude<LickState, 'pending'>): void;
+    compact(agentId: string): void;
+    clear(agentId: string): void;
+    setModel(agentId: string, model: string): void;
+    createScoop(parentId: string, name: string): Agent;
+    frozen(): readonly FrozenCone[];
+    freeze(agentId: string): void;
+    thaw(id: string): Agent | null;
+    discard(id: string): void;
+}
+export interface FrozenCone {
+    id: string;
+    name: string;
+    title: string;
+    model: string;
+    messages: number;
+    frozenAt: number;
 }
 export type FileKind = 'file' | 'directory';
 export interface FileEntry {
@@ -174,10 +334,122 @@ export interface SettingsPort extends Subscribable<SettingsEvents> {
     connect(id: string): Promise<void>;
     disconnect(id: string): void;
 }
+export type MemoryTag = 'user' | 'feedback' | 'project';
+export interface Memory {
+    id: string;
+    scope: string;
+    section: string;
+    title: string;
+    body: string;
+    tag: MemoryTag | null;
+    updatedAt: number;
+}
+export type MemoryDraft = Omit<Memory, 'id' | 'updatedAt'> & {
+    id?: string;
+};
+export interface MemoryEvents {
+    memories: readonly Memory[];
+}
+export interface MemoryPort extends Subscribable<MemoryEvents> {
+    list(): readonly Memory[];
+    save(memory: MemoryDraft): Memory;
+    remove(id: string): void;
+}
+export type MonitorStatus = 'active' | 'idle' | 'warn' | 'error';
+export interface MonitorVital {
+    id: string;
+    label: string;
+    value: string;
+    unit?: string;
+    delta?: string;
+    series?: number[];
+    ratio?: number;
+}
+export interface MonitorRow {
+    name: string;
+    meta: string;
+    status: MonitorStatus;
+    badges?: string[];
+}
+export interface MonitorSection {
+    id: string;
+    label: string;
+    rows: MonitorRow[];
+}
+export interface MonitorAlert {
+    id: string;
+    title: string;
+    detail: string;
+    severity: 'warn' | 'error';
+}
+export interface MonitorSnapshot {
+    vitals: MonitorVital[];
+    alerts: MonitorAlert[];
+    sections: MonitorSection[];
+    updatedAt: number;
+}
+export interface MonitorEvents {
+    snapshot: MonitorSnapshot;
+}
+export interface MonitorPort extends Subscribable<MonitorEvents> {
+    snapshot(): MonitorSnapshot;
+    resync(): void;
+}
+export interface Sprinkle {
+    id: string;
+    name: string;
+    title: string;
+    icon: string;
+    agentId: string;
+    html: string;
+}
+export interface SprinkleEvents {
+    sprinkles: readonly Sprinkle[];
+}
+export interface SprinklePort extends Subscribable<SprinkleEvents> {
+    list(): readonly Sprinkle[];
+    send(id: string, payload: unknown): void;
+}
+export type TrayConnection = 'offline' | 'connecting' | 'live' | 'stalled' | 'reconnecting' | 'error';
+export type FloatKind = 'npx' | 'sliccstart' | 'extension' | 'standalone' | 'cherry' | 'electron' | 'hosted';
+export type TrayRole = 'none' | 'leader' | 'follower';
+export interface Follower {
+    id: string;
+    name: string;
+    device: 'browser' | 'phone' | 'extension';
+    since: number;
+}
+export interface TrayStatus {
+    name: string;
+    kind: FloatKind;
+    connection: TrayConnection;
+    role: TrayRole;
+    followers: Follower[];
+    spent: number;
+    rate: number;
+    budget: {
+        percent: number;
+        window: 'daily' | 'weekly' | 'monthly';
+        resets: string;
+    };
+    joinUrl: string;
+}
+export interface TrayEvents {
+    status: TrayStatus;
+}
+export interface TrayPort extends Subscribable<TrayEvents> {
+    status(): TrayStatus;
+    reconnect(): void;
+    disconnect(): void;
+}
 export interface SliccModel {
     agent: AgentPort;
     files: FilePort;
     terminals: TerminalPort;
     browser: BrowserPort;
     settings: SettingsPort;
+    memory: MemoryPort;
+    monitor: MonitorPort;
+    sprinkles: SprinklePort;
+    tray: TrayPort;
 }

package/dist/types/ui.d.ts

@@ -1,15 +1,25 @@
 import './app/spectrum.ts';
 import { SliccAgents } from './app/agents.js';
 import { SliccApp } from './app/app.js';
+import { SliccBrowser } from './app/browser.js';
+import { SliccChanges, SliccDiffPanel } from './app/changes.js';
 import { SliccChat } from './app/chat.js';
+import { SliccComposer } from './app/composer.js';
+import { SliccFiles, SliccFileView } from './app/files.js';
+import { SliccCodeView, SliccDiffView } from './components/code-view.js';
 import { SliccDock } from './components/dock.js';
-export type { Color } from './app/app.js';
-export { resolveColor } from './app/app.js';
+import { SliccFileTree } from './components/file-tree.js';
+export type { Color } from './app/base.js';
+export { resolveColor } from './app/base.js';
+export type { GrammarKind } from './app/grammars.js';
+export { grammarBase, setGrammarBase } from './app/grammars.js';
 export type { Placement, Surface } from './app/panels.js';
 export { surfaces } from './app/panels.js';
+export type { CodeColor, DiffStyle } from './components/code-view.js';
 export type { PanelFactory, PanelParams } from './components/dock.js';
+export type { GitStatusEntry } from './components/file-tree.js';
 export type { Listener, Subscribable } from './model/emitter.js';
 export { Emitter } from './model/emitter.js';
 export type * from './model/types.js';
-export { SliccAgents, SliccApp, SliccChat, SliccDock };
+export { SliccAgents, SliccApp, SliccBrowser, SliccChanges, SliccChat, SliccCodeView, SliccComposer, SliccDiffPanel, SliccDiffView, SliccDock, SliccFiles, SliccFileTree, SliccFileView, };
 export declare function define(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-spectrum",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Web components for SLICC on Spectrum Web Components: the terminal, the app shell and its surfaces",
   "type": "module",
   "license": "Apache-2.0",
@@ -53,6 +53,18 @@
     "lint": "slicc-lint",
     "format": "biome check --write ."
   },
+  "peerDependencies": {
+    "@shikijs/langs": "4.5.0",
+    "@shikijs/themes": "4.5.0"
+  },
+  "peerDependenciesMeta": {
+    "@shikijs/langs": {
+      "optional": true
+    },
+    "@shikijs/themes": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@ai-ecoverse/slicc-kernel": "1.7.2",
     "@ai-ecoverse/slicc-shared-web": "1.4.1",
@@ -61,7 +73,10 @@
     "@biomejs/biome": "2.5.15",
     "@fontsource/source-code-pro": "5.3.0",
     "@happy-dom/global-registrator": "20.14.5",
+    "@pierre/diffs": "1.5.1",
+    "@pierre/trees": "1.0.0-beta.6",
     "@spectrum-web-components/action-button": "1.12.4",
+    "@spectrum-web-components/action-group": "1.12.4",
     "@spectrum-web-components/action-menu": "1.12.4",
     "@spectrum-web-components/badge": "1.12.4",
     "@spectrum-web-components/button": "1.12.4",
@@ -69,6 +84,8 @@
     "@spectrum-web-components/menu": "1.12.4",
     "@spectrum-web-components/picker": "1.12.4",
     "@spectrum-web-components/progress-circle": "1.12.4",
+    "@spectrum-web-components/search": "1.12.4",
+    "@spectrum-web-components/switch": "1.12.4",
     "@spectrum-web-components/textfield": "1.12.4",
     "@spectrum-web-components/theme": "1.12.4",
     "@types/node": "26.6.4",

package/dist/chunk-T5QFSUYQ.js

@@ -1,8 +0,0 @@
-import "./chunk-Q4AC2O6Z.js";
-
-// stub:wasm-inline
-var WASM_BASE64 = "";
-export {
-  WASM_BASE64
-};
-//# sourceMappingURL=chunk-T5QFSUYQ.js.map