@idleware/ringi 0.0.0-stage → 0.0.0

package/target/dts/app/view.d.ts

@@ -0,0 +1,64 @@
+import type { Budget, Proposal, Usage } from '../domain/decisions.ts';
+import type { Task } from '../domain/profiles.ts';
+import type { All, FileRef, Message } from '../protocol/index.ts';
+export declare const render: (all: All, m: Message, { max, files }?: {
+    max?: number;
+    files?: () => FileRef[];
+}) => string;
+export declare const oneLine: (m: Message) => string;
+export declare const asJson: (m: Message) => {
+    id: string;
+    from: string;
+    trust: "asserted" | "verified";
+    to: string[];
+    re: string | null;
+    kind: string | null;
+    state: string | null;
+    assign: string[] | null;
+    roles: Record<string, string> | null;
+    hop: number;
+    hopEff: number;
+    bad: string | null;
+    time: string;
+    subject: string;
+    body: string;
+    files: {
+        path: string;
+        size: number | null;
+    }[];
+    refused: import("../protocol/index.ts").Refused[];
+    trailers: import("../protocol/index.ts").Trailers;
+};
+export type TaskView = {
+    id: string;
+    subject: string;
+    requester: string;
+    assignees: string[];
+    roles: Record<string, string>;
+    taken: string[];
+    grant: string | null;
+    state: string;
+    by: string;
+    at: string;
+};
+export declare const taskView: (t: Task, taken: string[]) => TaskView;
+export type ProposalView = {
+    id: string;
+    subject: string;
+    from: string;
+    decider: string;
+    state: string;
+    budget: Budget | null;
+    stamps: Proposal['stamps'];
+    missing: string[];
+};
+export declare const proposalView: (x: Proposal) => ProposalView;
+export type GrantView = {
+    grant: string;
+    proposal: string;
+    subject: string;
+    budget: Budget;
+    revoked: boolean;
+    usage: Usage;
+};
+export declare const grantView: (x: Proposal, usage: Usage) => GrantView;

package/target/dts/cli/agent.d.ts

@@ -0,0 +1,10 @@
+import * as Agent from '../app/agent.ts';
+import type { Opts } from './args.ts';
+import type { Ctx } from './context.ts';
+export declare const showInbox: ({ R, me, s }: Ctx, res: Agent.Inbox, o: Opts) => void;
+export declare const inbox: (a: Ctx, o: Opts) => void;
+export declare const take: (a: Ctx, o: Opts) => void;
+export declare const whoami: (a: Ctx) => void;
+export declare const card: (a: Ctx, o: Opts) => void;
+export declare const ping: (a: Ctx, o: Opts) => void;
+export declare const wait: (a: Ctx, o: Opts) => Promise<void>;

package/target/dts/cli/args.d.ts

@@ -0,0 +1,13 @@
+import type { Entry } from '../protocol/files.ts';
+export declare const out: (s?: string) => void;
+export declare const dump: (v: unknown) => void;
+export type Opts = {
+    _: string[];
+    [key: string]: string | string[] | boolean | undefined;
+};
+export declare const parseArgs: (argv: string[]) => Opts;
+export declare const opt: (o: Opts, key: string) => string | undefined;
+export declare const list: (o: Opts, key: string) => string[];
+export declare const flag: (o: Opts, key: string) => boolean;
+export declare const textOf: (o: Opts) => string;
+export declare const attachments: (spec: string) => Entry[];

package/target/dts/cli/context.d.ts

@@ -0,0 +1,6 @@
+import * as Context from '../app/context.ts';
+import type { Opts } from './args.ts';
+export type { Ctx } from '../app/context.ts';
+export { isRef } from '../app/room.ts';
+export declare const parseTo: (v: unknown) => string[];
+export declare const operatorCtx: (o: Opts) => Context.Ctx;

package/target/dts/cli/index.d.ts

@@ -0,0 +1,5 @@
+import type { Profile } from '../domain/profiles.ts';
+export declare const TABLE: Array<[string, 'operator' | 'session' | 'agent' | 'both', string]>;
+export declare const helpMarkdown: () => string;
+export declare const main: (argv?: string[]) => Promise<void>;
+export type { Profile };

package/target/dts/cli/operator.d.ts

@@ -0,0 +1,8 @@
+import type { SessionView } from '../app/overview.ts';
+import type { Opts } from './args.ts';
+export declare const sessionLine: (s: SessionView) => string;
+export declare const where: (o: Opts) => Promise<void>;
+export declare const sessions: (o: Opts) => void;
+export declare const forget: (o: Opts) => void;
+export declare const hub: (o: Opts) => void;
+export declare const roomCmd: (o: Opts) => void;

package/target/dts/cli/session.d.ts

@@ -0,0 +1,7 @@
+import * as Session from '../app/session.ts';
+import type { Opts } from './args.ts';
+export declare const briefing: (s: Session.Session) => void;
+export declare const join: (o: Opts) => void;
+export declare const resume: (o: Opts) => void;
+export declare const stop: () => void;
+export declare const leave: () => void;

package/target/dts/cli/shared.d.ts

@@ -0,0 +1,20 @@
+import type { TaskView } from '../app/view.ts';
+import type { Opts } from './args.ts';
+import type { Ctx } from './context.ts';
+export declare const send: (a: Ctx, o: Opts) => void;
+export declare const reply: (a: Ctx, o: Opts) => void;
+export declare const read: (a: Ctx, o: Opts) => void;
+export declare const thread: (a: Ctx, o: Opts) => void;
+export declare const taskLine: (t: TaskView) => string;
+export declare const tasks: (a: Ctx, o: Opts) => void;
+export declare const log: (a: Ctx, o: Opts) => void;
+export declare const cat: (a: Ctx, o: Opts) => void;
+export declare const get: (a: Ctx, o: Opts) => void;
+export declare const who: (a: Ctx) => void;
+export declare const signals: (a: Ctx, o: Opts) => void;
+export declare const profileCmd: ({ R }: Ctx, o: Opts) => void;
+export declare const propose: (a: Ctx, o: Opts) => void;
+export declare const stamp_: (a: Ctx, o: Opts) => void;
+export declare const decide: (a: Ctx, o: Opts) => void;
+export declare const proposals: (a: Ctx, o: Opts) => void;
+export declare const grants: (a: Ctx, o: Opts) => void;

package/target/dts/cli/skill.d.ts

@@ -0,0 +1,4 @@
+import type { Opts } from './args.ts';
+export declare const SKILL: string;
+export declare const skillTargets: (project: boolean) => string[];
+export declare const skill: (o: Opts) => void;

package/target/dts/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { main } from './cli/index.ts';
+export { main };

package/target/dts/domain/decisions.d.ts

@@ -0,0 +1,65 @@
+import type { All, Message, Parsed } from '../protocol/index.ts';
+export declare const CAPABILITY = "decisions/1";
+export declare const ROOT = "operator";
+export declare const BUDGET_KEYS: readonly ['runs', 'run-seconds', 'concurrency'];
+export type Budget = {
+    runs: number;
+    'run-seconds': number;
+    concurrency: number;
+};
+export declare const STAMPS: string[];
+export declare const DECISIONS: string[];
+export type Authority = {
+    decide?: Record<string, Partial<Budget>>;
+};
+export type AuthorityAt = (control: string | null) => Authority | null;
+export declare const parseBudget: (s: string | null | undefined) => Budget | null | undefined;
+export declare const budgetText: (b: Budget) => string;
+export declare const parseDue: (s: string) => string;
+export declare const check: (m: Parsed, isRef: (s: string) => boolean) => string | null;
+export declare const mayDecide: (authority: Authority | null, decider: string, proposer: string, budget: Budget | null) => boolean;
+export type Grant = {
+    id: string;
+    budget: Budget;
+    proposal: Message;
+    revoked: boolean;
+};
+export type Proposal = {
+    proposal: Message;
+    decider: string;
+    reviewers: string[];
+    budget: Budget | null;
+    due: number | null;
+    stamps: Record<string, {
+        stamp: string;
+        id: string;
+        reason: string;
+    }>;
+    missing: string[];
+    decision: {
+        decision: string;
+        id: string;
+        by: string;
+        time: number;
+    } | null;
+    revoked: {
+        id: string;
+        by: string;
+        time: number;
+    } | null;
+    superseded: Message | null;
+    state: string;
+    grant: Grant | null;
+};
+export declare const proposalOf: (all: All, p: Message, authorityAt: AuthorityAt, now?: number) => Proposal;
+export declare const proposals: (all: All, authorityAt: AuthorityAt) => Proposal[];
+export declare const grantOf: (all: All, authorityAt: AuthorityAt, id: string) => Grant | null;
+export type Usage = {
+    runs: number;
+    open: number;
+    uncertain: number;
+    seconds: number;
+    left: number;
+};
+export declare const counted: (all: All, authorityAt: AuthorityAt, m: Message) => boolean;
+export declare const usageOf: (all: All, grant: Grant, now?: number) => Usage;

package/target/dts/domain/index.d.ts

@@ -0,0 +1,2 @@
+export declare const CAPABILITIES: Record<string, object>;
+export declare const unenforceable: (ids: string[]) => string | null;

package/target/dts/domain/profiles.d.ts

@@ -0,0 +1,39 @@
+import type { All, Message } from '../protocol/index.ts';
+export declare const PROFILE_SCHEMA = "ringi-profile/1";
+export declare const DEFAULT_PROFILE = "a2a-1";
+export declare const PROFILES_CAPABILITY = "profiles/1";
+export type Rules = {
+    assign?: string[];
+    roles?: string[];
+    grant?: string[];
+    [state: `state:${string}`]: string[] | undefined;
+};
+export type Profile = {
+    schema: typeof PROFILE_SCHEMA;
+    name: string;
+    description?: string;
+    opens: string;
+    states: string[];
+    initial: string;
+    terminal: string[];
+    waiting?: string;
+    rules: Rules;
+};
+export type Task = {
+    root: Message;
+    msgs: Message[];
+    state: string;
+    by: string;
+    at: number;
+    requester: string;
+    assignees: string[];
+    roles: Record<string, string>;
+    grant: string | null;
+    effects: Map<string, string[]>;
+};
+export declare const parseProfile: (text: string, label: string) => Profile;
+export declare const ruleFor: (profile: Profile, state: string) => string[] | undefined;
+export declare const taskFor: (all: All, m: Message, profile: Profile) => Message | null;
+export declare const taskOf: (all: All, root: Message, profile: Profile) => Task;
+export declare const tasksIn: (all: All, profile: Profile) => Task[];
+export declare const isOpen: (t: Task, profile: Profile) => boolean;

package/target/dts/domain/signals.d.ts

@@ -0,0 +1,37 @@
+import * as D from './decisions.ts';
+import type { Profile } from './profiles.ts';
+import type { All, Message } from '../protocol/index.ts';
+export type RoomModel = {
+    name: string;
+    genesis: string;
+    profile: Profile;
+    members: Record<string, unknown>;
+    authorityAt: D.AuthorityAt;
+};
+export type SignalRecord = {
+    ref: string;
+    object: string;
+    name: string;
+    actor: string;
+    target: string;
+    tagger: string;
+    text: string;
+};
+export declare const MARKS: string[];
+export declare const signalBody: (R: Pick<RoomModel, 'name' | 'genesis'>, who: string, id: string, signal: string) => string;
+export declare const markWhy: (R: RoomModel, actor: string, m: Message, mark: string) => string | undefined;
+export declare const marksOn: (checked: Checked[]) => Map<string, Record<string, string[]>>;
+export declare const effective: (R: RoomModel, all: All, m: Message) => string[];
+export type Checked = {
+    ref: string;
+    actor: string;
+    signal: string;
+    target: string;
+    ok: boolean;
+    why?: string;
+};
+export declare const check: (R: RoomModel, all: All, records: SignalRecord[]) => Checked[];
+export declare const pins: (records: SignalRecord[], checked: Checked[], accepted?: Record<string, string>) => {
+    accepted: Record<string, string>;
+    alarms: string[];
+};

package/target/dts/home/index.d.ts

@@ -0,0 +1,21 @@
+export declare const ROOT: string;
+export declare const RESOURCES: string;
+export declare const VERSION: string;
+export declare const HOME: string;
+export declare const HOME_VERSION = 3;
+export declare const OPERATOR = "operator";
+export declare const guard: <T>(fn: () => T) => T;
+export declare const mkdir: (d: string) => void;
+export declare const writeJson: (f: string, v: unknown) => void;
+export declare const readJson: <T>(f: string, dflt: T) => T;
+export declare const hubsDir: () => string;
+export declare const hubHome: (name: string) => string;
+export declare const ensureHome: () => void;
+export declare const locked: <T>(name: string, fn: () => T) => T;
+export type Config = {
+    hub: string;
+    room: string | null;
+};
+export declare const configFile: () => string;
+export declare const config: () => Config;
+export declare const setConfig: (patch: Partial<Config>) => void;

package/target/dts/hub/index.d.ts

@@ -0,0 +1,66 @@
+import * as D from '../domain/decisions.ts';
+import { OPERATOR } from '../home/index.ts';
+import type { Profile } from '../domain/profiles.ts';
+import { HIDDEN } from '../protocol/index.ts';
+import type { All, FileRef, Message } from '../protocol/index.ts';
+import type { Descriptor, Member, Rev, Store, StoredMessage, StoredRoom } from '../store/index.ts';
+import type { Entry } from '../protocol/files.ts';
+export declare const HUB_MAJOR = 1;
+export declare const CAPS: Set<string>;
+export declare const RESERVED_ROOMS: Set<string>;
+export type Contract = {
+    schema: 'ringi-hub';
+    version: string;
+    protocol: number;
+    trust: 'asserted' | 'signed';
+    capabilities?: string[];
+    profile?: string;
+    root?: string;
+    authority: D.Authority;
+};
+export type Hub = {
+    name: string;
+    dir: string;
+    d: Descriptor;
+    store: Store;
+    main: Rev;
+    contract: Contract;
+    signed: boolean;
+};
+export type Room = {
+    hub: Hub;
+    s: StoredRoom;
+    name: string;
+    archived: boolean;
+    head: Rev;
+    genesis: Rev;
+    contractRev: Rev;
+    contract: Contract;
+    authorityAt: D.AuthorityAt;
+    profile: Profile;
+    members: Record<string, Member>;
+};
+export declare const hubNames: () => string[];
+export declare const createHub: (name: string, { signed, url }?: {
+    signed?: boolean;
+    url?: string;
+}) => void;
+export declare const readDescriptor: (name: string) => Descriptor;
+export declare const contractAt: (store: Store, name: string, rev: Rev) => Contract;
+export declare const openHub: (name: string, { refresh }?: {
+    refresh?: boolean;
+}) => Hub;
+export declare const roomNames: (H: Hub, archived?: boolean) => string[];
+export declare const openRoom: (H: Hub, name: string | null | undefined, { quiet }?: {
+    quiet?: boolean;
+}) => Room | null;
+export declare const room: (H: Hub, name: string | null | undefined) => Room;
+export declare const ROOM_MD: (name: string) => string;
+export declare const profileText: (H: Hub, name: string) => string | null;
+export declare const controlChange: (R: Room, who: string, subject: string, mutate: (m: Record<string, Member>) => void, extra?: Array<[string, string]>) => void;
+export declare const toMessage: (R: Room, from: string, x: StoredMessage, seq: number) => Message;
+export declare const asStored: (R: Room) => All;
+export declare const append: (R: Room, who: string, text: string, entries?: Entry[]) => Rev;
+export declare const withSizes: (R: Room, m: Message) => FileRef[];
+export declare const pongText: (me: string, m: Message, what: string) => string;
+export { OPERATOR, HIDDEN };

package/target/dts/hub/signals.d.ts

@@ -0,0 +1,4 @@
+import type { All, Message } from '../protocol/index.ts';
+import type { Room } from './index.ts';
+export declare const mark: (R: Room, who: string, m: Message, name: string) => boolean;
+export declare const emit: (R: Room, who: string, all: All, m: Message) => number;

package/target/dts/index.d.ts

@@ -0,0 +1,8 @@
+export * from './protocol/index.ts';
+export * from './domain/profiles.ts';
+export * as decide from './domain/decisions.ts';
+export * as signals from './domain/signals.ts';
+export type { Store, StoreFactory, Descriptor, StoredRoom, StoredMessage, SignalRecord, Rev } from './store/index.ts';
+export { STORES } from './store/index.ts';
+export { openHub, openRoom, createHub, contractAt } from './hub/index.ts';
+export type { Hub, Room, Contract } from './hub/index.ts';

package/target/dts/lib/index.d.ts

@@ -0,0 +1,18 @@
+export declare class Fail extends Error {
+}
+export declare const fail: (msg: string) => never;
+export declare const note: (s: string) => void;
+export declare const sleep: (ms: number) => Promise<void>;
+export declare const when: (t: number) => string;
+export declare const bytes: (n: number) => string;
+export declare const short: (id: string) => string;
+export declare const stamp: () => string;
+export declare const words: (v: unknown) => string[];
+export declare const errno: (e: unknown) => string | undefined;
+export declare const writeJsonAtomic: (file: string, v: unknown) => void;
+export declare const strictJson: <T = unknown>(text: string, label?: string) => T;
+export declare const locked: <T>(file: string, fn: () => T, timeout?: number) => T;
+export declare const SANDBOX: RegExp;
+export declare const cannotWrite: (where: string, detail: string) => never;
+export declare const guardWrite: <T>(where: string, fn: () => T) => T;
+export declare const mkdirIn: (where: string, d: string) => void;

package/target/dts/protocol/files.d.ts

@@ -0,0 +1,9 @@
+export declare const CC_RE: RegExp;
+export type Entry = {
+    path: string;
+    file?: string;
+    content?: string;
+    mode: string;
+};
+export declare const checkPath: (p: string) => string;
+export declare const checkCollisions: (paths: string[]) => void;

package/target/dts/protocol/index.d.ts

@@ -0,0 +1,72 @@
+export declare const ID_RE: RegExp;
+export declare const TOKEN_RE: RegExp;
+export declare const HOP_RE: RegExp;
+export declare const TRAILER_RE: RegExp;
+export declare const TEXT_MAX: number;
+export declare const KNOWN: Set<string>;
+export declare const HEARTBEATS: Set<string>;
+export declare const HIDDEN: Set<string>;
+export type Trailers = Record<string, string[]>;
+export type FileRef = {
+    path: string;
+    size: number | null;
+};
+export type Refused = {
+    path: string;
+    mode?: string;
+    why?: string;
+};
+export type Message = {
+    id: string;
+    from: string;
+    trust: 'asserted' | 'verified';
+    time: number;
+    seq: number;
+    invalid: string | null;
+    subject: string;
+    body: string;
+    to: string[];
+    re: string | null;
+    kind: string | null;
+    state: string | null;
+    assign: string[] | null;
+    roles: Record<string, string> | null;
+    hop: number;
+    bad: string | null;
+    trailers: Trailers;
+    files: FileRef[];
+    refused: Refused[];
+    reId: string | null;
+    hopEff: number;
+};
+export type Logs = Map<string, Message[]>;
+export type All = Map<string, Message>;
+export type Parsed = Pick<Message, 'subject' | 'body' | 'to' | 're' | 'kind' | 'state' | 'assign' | 'roles' | 'hop' | 'bad' | 'trailers'>;
+export declare const one: (m: {
+    trailers: Trailers;
+}, k: string) => string | null;
+export declare const decodeText: (buf: Uint8Array) => {
+    text: string;
+    invalid?: undefined;
+} | {
+    invalid: string;
+    text?: undefined;
+};
+export declare const parse: (raw: string, isRef: (s: string) => boolean) => Parsed;
+export declare const compose: (text: string, trailers: Array<[string, string | null | undefined | false]>) => string;
+export declare const checkOutgoing: (text: string, isRef: (s: string) => boolean) => Parsed;
+export declare const link: (logs: Logs) => All;
+export declare const ordered: (list: Message[]) => Message[];
+export declare const chainHas: (all: All, m: Message, top: Message) => boolean;
+export declare const rootOf: (all: All, m: Message) => Message;
+export declare const under: (all: All, top: Message) => Message[];
+export declare const lookup: (all: All, ref: string) => Message;
+export declare const visible: (m: Message, id: string, hidden: Set<string>) => boolean;
+export declare const wakes: (m: Message, id: string, hidden: Set<string>) => boolean;
+export declare const unread: (logs: Logs, id: string, cursors: Record<string, string>, limit: number | undefined, hidden: Set<string>) => {
+    msgs: Message[];
+    rest: number;
+    cursors: {
+        [x: string]: string;
+    };
+};

package/target/dts/runtime/reader.d.ts

@@ -0,0 +1,34 @@
+import type { Room } from '../hub/index.ts';
+import type { All, Logs } from '../protocol/index.ts';
+import type { Rev } from '../store/index.ts';
+export type ReaderState = {
+    control?: Rev;
+    heads?: Record<string, Rev>;
+    alarms?: string[];
+    seen?: Record<string, string>;
+    watched?: Record<string, string>;
+    pending?: string[];
+    inflight?: {
+        seen: Record<string, string>;
+    };
+    heartbeatSeen?: Record<string, string>;
+    runs?: number[];
+    exhausted?: Record<string, boolean>;
+    signals?: Record<string, string>;
+};
+export declare const readerFile: (R: Room, reader: string) => string;
+export declare const readerLock: <T>(R: Room, reader: string, fn: () => T) => T;
+export declare const loadState: (R: Room, reader: string) => ReaderState;
+export declare const saveState: (R: Room, reader: string, st: ReaderState) => void;
+export declare const loadRoomUnlocked: (R: Room, reader: string) => {
+    logs: Logs;
+    st: ReaderState;
+};
+export declare const loadRoom: (R: Room, reader: string) => {
+    logs: Logs;
+    st: ReaderState;
+};
+export declare const linked: (R: Room, reader: string) => {
+    logs: Logs;
+    all: All;
+};

package/target/dts/runtime/session.d.ts

@@ -0,0 +1,42 @@
+import type { Hub, Room } from '../hub/index.ts';
+export declare const LEASE: number;
+export type Session = {
+    handle: string;
+    product: string | null;
+    hub: string;
+    room: string;
+    genesis: string;
+    agent: string;
+    scope: string | null;
+    state: 'active' | 'stopped';
+    since: string;
+    lastSeen: string;
+    pid: number | null;
+    takenFrom?: string;
+};
+export type Me = {
+    handle: string;
+    product: string | null;
+    pid: number | null;
+};
+export declare const whoAmI: () => Me;
+export declare const allSessions: () => Session[];
+export declare const readSession: (handle: string) => Session | null;
+export declare const saveSession: (s: Session) => void;
+export declare const dropSession: (handle: string) => void;
+export declare const pidAlive: (pid: number) => boolean;
+export declare const liveness: (s: Session) => 'active' | 'stopped' | 'gone';
+export declare const seatHolder: (hub: string, genesis: string, agent: string, except: string) => Session | undefined;
+export declare const ownSession: (handle: string) => Session | null;
+export type Bound = {
+    s: Session;
+    H: Hub;
+    R: Room;
+    me: string;
+};
+export declare const bound: () => Bound;
+export declare const parseSelector: (sel: string | undefined) => {
+    hub: string | null;
+    room: string;
+    agent: string;
+};

package/target/dts/runtime/watch.d.ts

@@ -0,0 +1,17 @@
+import type { Room } from '../hub/index.ts';
+export type WatchOptions = {
+    seat: string;
+    exec: string;
+    hub?: string;
+    scope?: string;
+    handoff?: boolean;
+    once?: boolean;
+    requireGrant?: boolean;
+    interval?: number;
+    from?: string[];
+    maxHop?: number;
+    maxRuns?: number;
+    window?: number;
+};
+export declare const watch: (w: WatchOptions, log?: (line: string) => void) => Promise<number>;
+export type { Room };