@ai-ecoverse/slicc-spectrum 1.0.0 → 1.2.0

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

@@ -0,0 +1,32 @@
+import { Emitter } from '../model/emitter.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, 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[];
+    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/browser.d.ts

@@ -0,0 +1,15 @@
+import { Emitter } from '../model/emitter.js';
+import type { BrowserEvents, BrowserPort, BrowserTab } from '../model/types.js';
+import type { Clock } from './clock.js';
+export declare function page(tab: BrowserTab): string;
+export declare class DummyBrowser extends Emitter<BrowserEvents> implements BrowserPort {
+    #private;
+    constructor(tabs: readonly BrowserTab[], clock: Clock);
+    list(): readonly BrowserTab[];
+    active(): string | null;
+    activate(id: string): void;
+    open(url: string, agentId?: string | null): BrowserTab;
+    navigate(id: string, url: string): void;
+    close(id: string): void;
+    screenshot(id: string): Promise<string>;
+}

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

@@ -0,0 +1,5 @@
+export interface Clock {
+    delay: number;
+    sleep(ticks?: number): Promise<void>;
+}
+export declare function clock(delay: number): Clock;

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/files.d.ts

@@ -0,0 +1,14 @@
+import { Emitter } from '../model/emitter.js';
+import type { Change, FileEntry, FileEvents, FilePort } from '../model/types.js';
+import type { Clock } from './clock.js';
+export declare class DummyFiles extends Emitter<FileEvents> implements FilePort {
+    #private;
+    constructor(contents: Record<string, string>, directories: readonly string[], changes: readonly Change[], clock: Clock);
+    list(): Promise<readonly FileEntry[]>;
+    read(path: string): Promise<string>;
+    write(path: string, text: string, agentId?: string | null): Promise<void>;
+    remove(path: string, agentId?: string | null): Promise<void>;
+    changes(): readonly Change[];
+    accept(path: string): void;
+    revert(path: string): Promise<void>;
+}

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

@@ -0,0 +1,12 @@
+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[];
+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/index.d.ts

@@ -0,0 +1,6 @@
+import type { SliccModel } from '../model/types.js';
+export interface DummyOptions {
+    delay?: number;
+    storage?: Storage | null;
+}
+export declare function createDummyModel({ delay, storage }?: DummyOptions): SliccModel;

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

@@ -0,0 +1,29 @@
+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;
+} | {
+    type: 'text';
+    text: string;
+} | {
+    type: 'tool';
+    name: string;
+    title: string;
+    input: string;
+    output: string;
+    paths: string[];
+    ticks: number;
+    effect?: (effects: Effects) => Promise<unknown> | unknown;
+};
+export declare function script(prompt: string, attachments?: readonly Attachment[]): {
+    steps: Step[];
+    suggestion: string;
+};

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

@@ -0,0 +1,13 @@
+import { Emitter } from '../model/emitter.js';
+import type { Account, ModelOption, Settings, SettingsEvents, SettingsPort } from '../model/types.js';
+import type { Clock } from './clock.js';
+export declare class DummySettings extends Emitter<SettingsEvents> implements SettingsPort {
+    #private;
+    constructor(defaults: Settings, models: readonly ModelOption[], accounts: readonly Account[], storage: Storage | null, clock: Clock);
+    get(): Settings;
+    update(patch: Partial<Settings>): void;
+    models(): readonly ModelOption[];
+    accounts(): readonly Account[];
+    connect(id: string): Promise<void>;
+    disconnect(id: string): void;
+}

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

@@ -0,0 +1,16 @@
+import type { TerminalBackend, TerminalSession, TerminalSignal, TerminalSink } from '../backend.js';
+import type { FilePort } from '../model/types.js';
+import type { Clock } from './clock.js';
+export declare function resolve(cwd: string, target: string): string;
+export declare class FakeShell implements TerminalSession {
+    #private;
+    cwd: string;
+    closed: boolean;
+    constructor(sink: TerminalSink, files: FilePort, cwd: string, clock: Clock);
+    history(): readonly string[];
+    write(data: Uint8Array): void;
+    resize(): void;
+    signal(name: TerminalSignal): void;
+    close(): void;
+}
+export declare function shellBackend(files: FilePort, cwd: string, clock: Clock): TerminalBackend;

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/terminals.d.ts

@@ -0,0 +1,15 @@
+import type { TerminalBackend } from '../backend.js';
+import { Emitter } from '../model/emitter.js';
+import type { FilePort, TerminalEvents, TerminalInfo, TerminalPort } from '../model/types.js';
+import type { Clock } from './clock.js';
+export declare class DummyTerminals extends Emitter<TerminalEvents> implements TerminalPort {
+    #private;
+    constructor(terminals: readonly TerminalInfo[], files: FilePort, clock: Clock);
+    list(): readonly TerminalInfo[];
+    open({ cwd, agentId, }?: {
+        cwd?: string;
+        agentId?: string | null;
+    }): TerminalInfo;
+    close(id: string): void;
+    backend(id: string): TerminalBackend;
+}

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/dummy.d.ts

@@ -0,0 +1,2 @@
+export type { DummyOptions } from './dummy/index.js';
+export { createDummyModel } from './dummy/index.js';

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

@@ -0,0 +1,9 @@
+export type Listener<T> = (detail: T) => void;
+export interface Subscribable<Events extends object> {
+    on<K extends keyof Events>(type: K, listener: Listener<Events[K]>): () => void;
+}
+export declare class Emitter<Events extends object> implements Subscribable<Events> {
+    #private;
+    on<K extends keyof Events>(type: K, listener: Listener<Events[K]>): () => void;
+    emit<K extends keyof Events>(type: K, detail: Events[K]): void;
+}