@ai-ecoverse/slicc-agent 3.3.0 → 3.4.0

package/dist/types/licks/config.d.ts

@@ -0,0 +1,35 @@
+import type { LickTarget } from './lick.ts';
+export interface CronEntry {
+    name: string;
+    schedule: string;
+    target: LickTarget;
+    message: string;
+}
+export interface WatchEntry {
+    name: string;
+    path: string;
+    glob: string;
+    target: LickTarget;
+    message: string;
+    debounce: number;
+}
+export interface WebhookEntry {
+    name: string;
+    target: LickTarget;
+    message: string;
+}
+export interface ConfigError {
+    file: string;
+    line?: number;
+    error: string;
+}
+export interface Parsed<T> {
+    entries: T[];
+    errors: ConfigError[];
+}
+export declare function isName(value: string): boolean;
+export declare function isTarget(value: string): value is LickTarget;
+export declare function parseCrontab(file: string, text: string): Parsed<CronEntry>;
+export declare function nameOf(file: string): string;
+export declare function parseWatch(file: string, source: string, home: string): WatchEntry;
+export declare function parseWebhook(file: string, source: string): WebhookEntry;

package/dist/types/licks/cron.d.ts

@@ -0,0 +1,16 @@
+export interface Schedule {
+    minutes: ReadonlySet<number>;
+    hours: ReadonlySet<number>;
+    days: ReadonlySet<number>;
+    months: ReadonlySet<number>;
+    weekdays: ReadonlySet<number>;
+    anyDay: boolean;
+    anyWeekday: boolean;
+}
+export declare function parseSchedule(expression: string): Schedule;
+export declare function nextFire(schedule: Schedule, after: number): number | null;
+export interface Missed {
+    count: number;
+    more: boolean;
+}
+export declare function missedFires(schedule: Schedule, from: number, until: number, cap?: number): Missed;

package/dist/types/licks/extension.d.ts

@@ -0,0 +1,22 @@
+import type { Context } from '@earendil-works/chord';
+import { type Conversation, type ConversationId } from '@earendil-works/pi-durable';
+import { type Missed } from './cron.ts';
+import type { LickTarget } from './lick.ts';
+import type { Licks } from './licks.ts';
+export declare const LICKS_SECTION: string;
+export type ConversationLookup = (id: ConversationId, context: Context) => Promise<Conversation>;
+export interface CronInput {
+    name: string;
+    schedule: string;
+    target: LickTarget;
+    message: string;
+    from: number;
+}
+type CronState = {
+    phase: 'wait';
+    at: number | null;
+};
+export declare function cronText(schedule: string, at: number, missed: Missed): string;
+export declare function cronTask(licks: Licks): import("@earendil-works/pi-durable").Task<CronInput, CronState, null, object>;
+export declare function licksExtension(licks: Licks, conversation: ConversationLookup, cron?: ReturnType<typeof cronTask>): import("@earendil-works/pi-durable").Extension<import("@earendil-works/pi-durable").ToolRegistration>;
+export {};

package/dist/types/licks/fswatch.d.ts

@@ -0,0 +1,20 @@
+import type { Context } from '@earendil-works/chord';
+import type { ExecutionEnv } from '@earendil-works/pi-durable/env';
+import type { Activity } from '../kernel/activity.ts';
+import { type ConfigError } from './config.ts';
+import type { LickEvent } from './licks.ts';
+export interface ConfigFiles {
+    read(path: string, context: Context): Promise<string | undefined>;
+    list(path: string, context: Context): Promise<string[]>;
+}
+export type Deliver = (event: LickEvent, context: Context) => Promise<void>;
+export declare function relativeTo(base: string, path: string): string | undefined;
+export declare function configFiles(env: ExecutionEnv): ConfigFiles;
+export declare class Watches {
+    #private;
+    constructor(env: ExecutionEnv, deliver: Deliver, home: string, activity?: Activity);
+    get names(): string[];
+    stop(name: string, context: Context): Promise<void>;
+    reconcile(dir: string, context: Context): Promise<ConfigError[]>;
+    close(context: Context): Promise<void>;
+}

package/dist/types/licks/glob.d.ts

@@ -0,0 +1 @@
+export declare function glob(pattern: string): (path: string) => boolean;

package/dist/types/licks/index.d.ts

@@ -0,0 +1,24 @@
+import type { Conversation, Harness, Registry } from '@earendil-works/pi-durable';
+import type { ExecutionEnv } from '@earendil-works/pi-durable/env';
+import type { Activity } from '../kernel/activity.ts';
+import { type Licks } from './licks.ts';
+import { type LickSources } from './sources.ts';
+export interface LicksAgent {
+    harness: Harness;
+    root: Conversation;
+    cone(): Conversation;
+}
+export interface LicksSetup {
+    licks: Licks;
+    attach(agent: LicksAgent, options: {
+        env: ExecutionEnv;
+        home: string;
+        now?: () => number;
+        flushEvery?: number;
+        activity?: Activity;
+    }): LickSources;
+}
+export declare function setupLicks(registry: Registry): LicksSetup;
+export type { Lick, LickChannel } from './lick.ts';
+export type { LickEvent, Licks } from './licks.ts';
+export type { LickSources, WebhookDelivery } from './sources.ts';

package/dist/types/licks/lick.d.ts

@@ -0,0 +1,21 @@
+export declare const LICK_CHANNELS: readonly ['webhook', 'cron', 'sprinkle', 'fswatch', 'session-reload', 'navigate', 'discovery', 'upgrade', 'workflow', 'bash', 'jshd', 'preview', 'cherry', 'scoop-notify', 'scoop-idle', 'scoop-wait', 'sudo-request'];
+export type LickChannel = (typeof LICK_CHANNELS)[number];
+export type LickAction = 'confirm' | 'dismiss';
+export type LickTarget = 'cone' | `scoop:${string}`;
+export type Lick = {
+    id: string;
+    channel: LickChannel;
+    source: string;
+    title: string;
+    text: string;
+    body?: string;
+    count: number;
+    at: number;
+    actions?: LickAction[];
+};
+export declare function escapeText(value: string): string;
+export declare function escapeAttribute(value: string): string;
+export declare function unescape(value: string): string;
+export declare function lickId(): string;
+export declare function formatLick(lick: Lick): string;
+export declare function parseLick(text: string): Lick | undefined;

package/dist/types/licks/licks.d.ts

@@ -0,0 +1,56 @@
+import type { Context } from '@earendil-works/chord';
+import { type Conversation, type Harness } from '@earendil-works/pi-durable';
+import { type Lick, type LickAction, type LickChannel, type LickTarget } from './lick.ts';
+import { LICK_STATE_KIND, type LickDecision } from './state.ts';
+export interface LickEvent {
+    channel: LickChannel;
+    source: string;
+    title: string;
+    text: string;
+    body?: string;
+    items?: string[];
+    count?: number;
+    target: LickTarget;
+    coalesce?: boolean;
+    eventId?: string;
+    at?: number;
+}
+type Pending = {
+    lick: Lick;
+    items: string[];
+    body: string | null;
+};
+type Queue = {
+    submission: number | null;
+    pending: Pending | null;
+};
+type OutboxState = {
+    queues: Record<string, Queue>;
+    events: Record<string, string[]>;
+};
+export declare const LicksOutbox: import("@earendil-works/pi-durable").SessionDocToken<OutboxState>;
+export interface LickHandler {
+    confirm?(lick: Lick, reason: string | undefined, context: Context): Promise<string | undefined>;
+    dismiss?(lick: Lick, reason: string | undefined, context: Context): Promise<string | undefined>;
+}
+export interface LickFound {
+    lick: Lick;
+    decision: LickDecision | undefined;
+}
+export interface Licks {
+    deliver(event: LickEvent, context: Context): Promise<void>;
+    flush(context: Context): Promise<void>;
+    find(conversation: Conversation, id: string, context: Context): Promise<LickFound | undefined>;
+    decide(conversation: Conversation, id: string, action: LickAction, reason: string | undefined, context: Context): Promise<string>;
+    handle(channel: LickChannel, handler: LickHandler): void;
+    pending(context: Context): Promise<number>;
+}
+export interface LicksHost {
+    harness: Harness;
+    resolve(target: LickTarget, context: Context): Promise<Conversation>;
+}
+export declare const MAX_ITEMS = 50;
+export declare const MAX_EVENTS = 64;
+export declare function render(pending: Pending): Lick;
+export declare function createLicks(host: Promise<LicksHost>): Licks;
+export { LICK_STATE_KIND };

package/dist/types/licks/schedules.d.ts

@@ -0,0 +1,25 @@
+import type { Context } from '@earendil-works/chord';
+import { type Conversation, type Harness } from '@earendil-works/pi-durable';
+import type { CronEntry } from './config.ts';
+import type { cronTask } from './extension.ts';
+type CronRecord = {
+    schedule: string;
+    target: string;
+    message: string;
+    task: number;
+};
+type HostState = {
+    cron: Record<string, CronRecord>;
+    agent: string | null;
+    boot: string | null;
+    mark: number;
+    upgrades: number;
+};
+export declare const LicksHostDoc: import("@earendil-works/pi-durable").SessionDocToken<HostState>;
+export declare function reconcileCron(options: {
+    harness: Harness;
+    root: Conversation;
+    cron: ReturnType<typeof cronTask>;
+    now: () => number;
+}, entries: readonly CronEntry[], context: Context): Promise<void>;
+export {};

package/dist/types/licks/sources.d.ts

@@ -0,0 +1,38 @@
+import type { Context } from '@earendil-works/chord';
+import type { Conversation, Harness } from '@earendil-works/pi-durable';
+import type { ExecutionEnv } from '@earendil-works/pi-durable/env';
+import type { Activity } from '../kernel/activity.ts';
+import { type BootFacts } from './boot.ts';
+import { type ConfigError, type WebhookEntry } from './config.ts';
+import type { cronTask } from './extension.ts';
+import type { LickEvent, Licks } from './licks.ts';
+export declare const SLICC_DIR = ".slicc";
+export interface LickSourcesOptions {
+    harness: Harness;
+    root: Conversation;
+    cone: () => Conversation;
+    env: ExecutionEnv;
+    home: string;
+    licks: Licks;
+    cron: ReturnType<typeof cronTask>;
+    now?: () => number;
+    flushEvery?: number;
+    activity?: Activity;
+}
+export interface WebhookDelivery {
+    id?: string;
+    headers?: Record<string, string>;
+    body: unknown;
+}
+export interface LickSources {
+    start(context: Context): Promise<void>;
+    reconcile(context: Context): Promise<void>;
+    boot(facts: BootFacts, context: Context): Promise<void>;
+    webhook(name: string, delivery: WebhookDelivery, context: Context): Promise<boolean>;
+    close(context: Context): Promise<void>;
+}
+export declare function hash(text: string): string;
+export declare function shortPath(path: string, home: string): string;
+export declare function configLick(error: ConfigError, home: string): LickEvent;
+export declare function webhookLick(name: string, entry: WebhookEntry, delivery: WebhookDelivery): LickEvent;
+export declare function createLickSources(options: LickSourcesOptions): LickSources;

package/dist/types/licks/state.d.ts

@@ -0,0 +1,14 @@
+import { type Lick } from './lick.ts';
+export type LickDecision = 'confirmed' | 'dismissed';
+export declare const LICK_TOOLS: Record<string, LickDecision>;
+export declare const LICK_STATE_KIND = "slicc.lick-state";
+interface EntryLike {
+    id: number;
+    kind: string;
+    model?: readonly unknown[];
+    data?: unknown;
+}
+export declare function userText(entry: EntryLike): string | undefined;
+export declare function entryLick(entry: EntryLike): Lick | undefined;
+export declare function lickDecisions(entries: readonly EntryLike[]): Map<string, LickDecision>;
+export {};

package/dist/types/services.d.ts

@@ -39,6 +39,24 @@ export interface AgentControl {
     reset(handoff: string | null, context: Context): Promise<void>;
     configure(change: AgentSettingsChange, context: Context): Promise<void>;
     rewind(messageId: string | null, context: Context): Promise<Rewound>;
+    resolveLick(lickId: string, state: 'confirmed' | 'dismissed', context: Context): Promise<LickResolved>;
+    webhook(name: string, delivery: WebhookRequest, context: Context): Promise<{
+        delivered: boolean;
+    }>;
+}
+export type LickResolved = {
+    done: true;
+    text: string;
+    error: null;
+} | {
+    done: false;
+    text: null;
+    error: string;
+};
+export interface WebhookRequest {
+    id: string | null;
+    headers: Record<string, string>;
+    body: string;
 }
 export type Rewound = {
     done: true;

package/dist/types/spectrum/agent-port.d.ts

@@ -18,7 +18,7 @@ export declare class AgentAdapter extends Emitter<AgentEvents> implements AgentP
     unqueue(_agentId: string, messageId: string): void;
     suggestion(): string | null;
     answer(): void;
-    resolveLick(): void;
+    resolveLick(_agentId: string, messageId: string, state: 'confirmed' | 'dismissed'): void;
     compact(): void;
     clear(): void;
     setModel(_agentId: string, model: string): void;

package/dist/types/system.d.ts

@@ -9,3 +9,4 @@ export declare function commandsOnPath(client: KernelClient): Promise<string[]>;
 export declare function transportName(transport: Transport | undefined): string;
 export declare function agentVersion(fetcher: (url: URL) => Promise<Response>, url?: URL): Promise<string>;
 export declare function systemSection(facts: SystemFacts): string;
+export declare function kernelBoot(client: KernelClient): Promise<string | null>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-agent",
-  "version": "3.3.0",
+  "version": "3.4.0",
   "description": "SLICC's agent core on pi durable: an agent worker, session storage, remoting and pi extensions",
   "type": "module",
   "license": "Apache-2.0",