@undefineds.co/linx 0.3.5 → 0.3.7

package/vendor/agent-runtime/dist/file-sync.d.ts

@@ -0,0 +1,157 @@
+import { type LinxSyncAuthority, type LinxSyncCheckpointStore, type LinxSyncContext, type LinxSyncDirection, type LinxSyncOperationKind, type LinxSyncPlane, type LinxSyncRunResult } from './sync.js';
+type MaybePromise<T> = T | Promise<T>;
+export type FileSyncShape = 'file-to-file' | 'file-to-json-list';
+export type FileSyncWriteMode = 'overwrite' | 'append';
+export type FileSyncContent = string | Uint8Array;
+export type FileSyncJsonRecord = Record<string, unknown>;
+export interface FileSyncArtifactRef {
+    uri?: string;
+    local?: string;
+    contentType?: string;
+    etag?: string;
+    checksum?: string;
+    offset?: number;
+    size?: number;
+    updatedAt?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface FileSyncReadResult {
+    uri?: string;
+    local?: string;
+    content: FileSyncContent;
+    contentType?: string;
+    etag?: string;
+    checksum?: string;
+    offset?: number;
+    size?: number;
+    updatedAt?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface FileSyncWriteCondition {
+    etag?: string;
+    offset?: number;
+}
+export interface FileSyncWriteInput {
+    source: FileSyncArtifactRef;
+    target: FileSyncArtifactRef;
+    content: FileSyncContent;
+    contentType?: string;
+    mode: FileSyncWriteMode;
+    expectedTarget?: FileSyncWriteCondition;
+    metadata?: Record<string, unknown>;
+}
+export interface FileSyncWriteResult {
+    uri?: string;
+    local?: string;
+    contentType?: string;
+    etag?: string;
+    checksum?: string;
+    offset?: number;
+    size?: number;
+    updatedAt?: string;
+    bytesWritten?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface FileSyncTaskContext {
+    signal?: AbortSignal;
+    now: () => Date;
+    metadata?: Record<string, unknown>;
+    sync: LinxSyncContext;
+}
+export type FileSyncRead = (ref: FileSyncArtifactRef, context: FileSyncTaskContext) => MaybePromise<FileSyncReadResult>;
+export type FileSyncWrite = (input: FileSyncWriteInput, context: FileSyncTaskContext) => MaybePromise<FileSyncWriteResult | void>;
+export interface FileSyncArtifactMaterializedEvent {
+    kind: 'artifact.materialized';
+    shape: 'file-to-file';
+    source: FileSyncArtifactRef;
+    target: FileSyncArtifactRef;
+    writeMode: FileSyncWriteMode;
+    contentType?: string;
+    bytesRead?: number;
+    bytesWritten?: number;
+    emittedAt: string;
+    metadata?: Record<string, unknown>;
+}
+export interface FileSyncRecordsMaterializedEvent {
+    kind: 'records.materialized';
+    shape: 'file-to-json-list';
+    source: FileSyncArtifactRef;
+    records: FileSyncJsonRecord[];
+    recordCount: number;
+    contentType?: string;
+    bytesRead?: number;
+    emittedAt: string;
+    metadata?: Record<string, unknown>;
+}
+export type FileSyncMaterializedEvent = FileSyncArtifactMaterializedEvent | FileSyncRecordsMaterializedEvent;
+export interface FileSyncScopeOptions {
+    source: string;
+    target: string;
+    direction?: LinxSyncDirection;
+    plane?: LinxSyncPlane;
+    authority?: LinxSyncAuthority;
+    signal?: AbortSignal;
+    now?: () => Date;
+    metadata?: Record<string, unknown>;
+    checkpoint?: LinxSyncCheckpointStore;
+    checkpointId?: string | ((result: LinxSyncRunResult) => string);
+    onEvent?: (event: FileSyncMaterializedEvent, result: LinxSyncRunResult) => MaybePromise<void>;
+    onResult?: (result: LinxSyncRunResult) => MaybePromise<void>;
+}
+export interface FileSyncTaskOptionsBase<TEvent extends FileSyncMaterializedEvent> {
+    action?: string;
+    operationId?: string;
+    checkpointId?: string | ((result: LinxSyncRunResult) => string);
+    subject?: string | null;
+    kind?: LinxSyncOperationKind;
+    source?: string;
+    target?: string;
+    direction?: LinxSyncDirection;
+    plane?: LinxSyncPlane;
+    authority?: LinxSyncAuthority;
+    metadata?: Record<string, unknown>;
+    onEvent?: (event: TEvent, result: LinxSyncRunResult) => MaybePromise<void>;
+    onResult?: (result: LinxSyncRunResult) => MaybePromise<void>;
+}
+export interface FileToFileSyncTaskOptions extends FileSyncTaskOptionsBase<FileSyncArtifactMaterializedEvent> {
+    sourceFile: FileSyncArtifactRef;
+    targetFile: FileSyncArtifactRef;
+    read: FileSyncRead;
+    write: FileSyncWrite;
+    writeMode?: FileSyncWriteMode;
+    expectedTarget?: FileSyncWriteCondition;
+    requireAppendCondition?: boolean;
+}
+export interface FileToJsonListSyncTaskOptions extends FileSyncTaskOptionsBase<FileSyncRecordsMaterializedEvent> {
+    sourceFile: FileSyncArtifactRef;
+    read: FileSyncRead;
+    parse?: FileSyncJsonListParser;
+    parseOptions?: FileSyncJsonListParseOptions;
+}
+export interface FileSyncJsonListParseOptions {
+    format?: 'auto' | 'json' | 'jsonl';
+    allowSingleRecord?: boolean;
+}
+export type FileSyncJsonListParser = (content: FileSyncContent, options?: FileSyncJsonListParseOptions) => FileSyncJsonRecord[];
+export declare class FileSyncScope {
+    private readonly options;
+    private readonly results;
+    private sequence;
+    constructor(options: FileSyncScopeOptions);
+    getResults(): LinxSyncRunResult[];
+    getLastResult(): LinxSyncRunResult | null;
+    fileToFile(options: FileToFileSyncTaskOptions): Promise<FileSyncArtifactMaterializedEvent>;
+    fileToJsonList(options: FileToJsonListSyncTaskOptions): Promise<FileSyncRecordsMaterializedEvent>;
+    private nextOperationId;
+}
+export declare function createFileSyncScope(options: FileSyncScopeOptions): FileSyncScope;
+export declare function parseFileSyncJsonList(content: FileSyncContent, options?: FileSyncJsonListParseOptions): FileSyncJsonRecord[];
+export declare function createFileSyncMetadata(input: {
+    action: string;
+    shape: FileSyncShape;
+    source?: FileSyncArtifactRef | null;
+    target?: FileSyncArtifactRef | null;
+    writeMode?: FileSyncWriteMode;
+    metadata?: Record<string, unknown> | null;
+}): Record<string, unknown>;
+export {};

package/vendor/agent-runtime/dist/file-sync.js

@@ -0,0 +1,314 @@
+import { runLinxSyncTask, } from './sync.js';
+export class FileSyncScope {
+    options;
+    results = [];
+    sequence = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    getResults() {
+        return [...this.results];
+    }
+    getLastResult() {
+        return this.results.length > 0 ? this.results[this.results.length - 1] : null;
+    }
+    async fileToFile(options) {
+        const action = options.action ?? defaultFileToFileAction(options.writeMode);
+        const writeMode = options.writeMode ?? 'overwrite';
+        const initialMetadata = createFileSyncMetadata({
+            action,
+            shape: 'file-to-file',
+            source: options.sourceFile,
+            target: options.targetFile,
+            writeMode,
+            metadata: {
+                ...this.options.metadata,
+                ...options.metadata,
+            },
+        });
+        const operationId = options.operationId ?? this.nextOperationId(action, options.subject ?? options.targetFile.local ?? options.targetFile.uri);
+        const run = await runLinxSyncTask({
+            operationId,
+            kind: options.kind ?? (writeMode === 'append' ? 'update' : 'upsert'),
+            description: action,
+            source: options.source ?? this.options.source,
+            target: options.target ?? this.options.target,
+            direction: options.direction ?? this.options.direction ?? 'local-to-core',
+            plane: options.plane ?? this.options.plane ?? 'projection',
+            authority: options.authority ?? this.options.authority ?? 'core',
+            signal: this.options.signal,
+            now: this.options.now,
+            checkpoint: this.options.checkpoint,
+            checkpointId: options.checkpointId ?? this.options.checkpointId ?? operationId,
+            initialMetadata,
+            metadata: (event) => ({
+                ...initialMetadata,
+                bytesRead: event.bytesRead,
+                bytesWritten: event.bytesWritten,
+                contentType: event.contentType,
+            }),
+            onResult: async (result) => {
+                this.results.push(result);
+                await this.options.onResult?.(result);
+                await options.onResult?.(result);
+            },
+            task: async (syncContext) => {
+                if (writeMode === 'append' && options.requireAppendCondition && !hasWriteCondition(options.expectedTarget)) {
+                    throw new Error('Append file sync requires an expected target etag or offset.');
+                }
+                const context = createFileSyncTaskContext(syncContext);
+                const readResult = await options.read(options.sourceFile, context);
+                const contentType = readResult.contentType ?? options.sourceFile.contentType ?? options.targetFile.contentType;
+                const bytesRead = contentByteLength(readResult.content);
+                const rawWriteResult = await options.write({
+                    source: mergeArtifactRef(options.sourceFile, readResult),
+                    target: options.targetFile,
+                    content: readResult.content,
+                    contentType,
+                    mode: writeMode,
+                    expectedTarget: options.expectedTarget,
+                    metadata: {
+                        ...readResult.metadata,
+                        ...options.metadata,
+                    },
+                }, context);
+                const writeResult = normalizeFileSyncWriteResult(rawWriteResult);
+                const target = mergeArtifactRef(options.targetFile, writeResult);
+                const event = {
+                    kind: 'artifact.materialized',
+                    shape: 'file-to-file',
+                    source: mergeArtifactRef(options.sourceFile, readResult),
+                    target,
+                    writeMode,
+                    contentType: writeResult?.contentType ?? contentType,
+                    bytesRead,
+                    bytesWritten: writeResult?.bytesWritten ?? bytesRead,
+                    emittedAt: context.now().toISOString(),
+                    metadata: compactMetadata({
+                        ...this.options.metadata,
+                        ...options.metadata,
+                        ...readResult.metadata,
+                        ...writeResult?.metadata,
+                    }),
+                };
+                return event;
+            },
+        });
+        await this.options.onEvent?.(run.value, run.result);
+        await options.onEvent?.(run.value, run.result);
+        return run.value;
+    }
+    async fileToJsonList(options) {
+        const action = options.action ?? 'file.records.materialize';
+        const initialMetadata = createFileSyncMetadata({
+            action,
+            shape: 'file-to-json-list',
+            source: options.sourceFile,
+            metadata: {
+                ...this.options.metadata,
+                ...options.metadata,
+            },
+        });
+        const operationId = options.operationId ?? this.nextOperationId(action, options.subject ?? options.sourceFile.local ?? options.sourceFile.uri);
+        const run = await runLinxSyncTask({
+            operationId,
+            kind: options.kind ?? 'upsert',
+            description: action,
+            source: options.source ?? this.options.source,
+            target: options.target ?? this.options.target,
+            direction: options.direction ?? this.options.direction ?? 'core-to-local',
+            plane: options.plane ?? this.options.plane ?? 'projection',
+            authority: options.authority ?? this.options.authority ?? 'core',
+            signal: this.options.signal,
+            now: this.options.now,
+            checkpoint: this.options.checkpoint,
+            checkpointId: options.checkpointId ?? this.options.checkpointId ?? operationId,
+            initialMetadata,
+            metadata: (event) => ({
+                ...initialMetadata,
+                bytesRead: event.bytesRead,
+                contentType: event.contentType,
+                recordCount: event.recordCount,
+            }),
+            onResult: async (result) => {
+                this.results.push(result);
+                await this.options.onResult?.(result);
+                await options.onResult?.(result);
+            },
+            task: async (syncContext) => {
+                const context = createFileSyncTaskContext(syncContext);
+                const readResult = await options.read(options.sourceFile, context);
+                const parser = options.parse ?? parseFileSyncJsonList;
+                const records = parser(readResult.content, options.parseOptions);
+                const event = {
+                    kind: 'records.materialized',
+                    shape: 'file-to-json-list',
+                    source: mergeArtifactRef(options.sourceFile, readResult),
+                    records,
+                    recordCount: records.length,
+                    contentType: readResult.contentType ?? options.sourceFile.contentType,
+                    bytesRead: contentByteLength(readResult.content),
+                    emittedAt: context.now().toISOString(),
+                    metadata: compactMetadata({
+                        ...this.options.metadata,
+                        ...options.metadata,
+                        ...readResult.metadata,
+                    }),
+                };
+                return event;
+            },
+        });
+        await this.options.onEvent?.(run.value, run.result);
+        await options.onEvent?.(run.value, run.result);
+        return run.value;
+    }
+    nextOperationId(action, subject) {
+        const timestamp = (this.options.now?.() ?? new Date()).toISOString().replace(/[:.]/g, '-');
+        return `${this.options.source}:${action}:${normalizeOperationSegment(subject ?? 'file')}:${timestamp}:${++this.sequence}`;
+    }
+}
+export function createFileSyncScope(options) {
+    return new FileSyncScope(options);
+}
+export function parseFileSyncJsonList(content, options = {}) {
+    const format = options.format ?? 'auto';
+    const text = contentToText(content).trim();
+    if (!text) {
+        return [];
+    }
+    if (format === 'jsonl') {
+        return parseJsonLines(text);
+    }
+    if (format === 'json') {
+        return normalizeJsonList(JSON.parse(text), options);
+    }
+    try {
+        return normalizeJsonList(JSON.parse(text), options);
+    }
+    catch (error) {
+        if (!looksLikeJsonLines(text)) {
+            throw error;
+        }
+        return parseJsonLines(text);
+    }
+}
+export function createFileSyncMetadata(input) {
+    return compactMetadata({
+        action: input.action,
+        shape: input.shape,
+        artifacts: compactMetadata({
+            source: compactArtifactMetadataRef(input.source),
+            target: compactArtifactMetadataRef(input.target),
+        }),
+        contentType: input.source?.contentType ?? input.target?.contentType,
+        writeMode: input.writeMode,
+        ...input.metadata,
+    });
+}
+function compactArtifactMetadataRef(ref) {
+    if (!ref) {
+        return undefined;
+    }
+    const compacted = compactMetadata({
+        uri: ref.uri,
+        local: ref.local,
+        contentType: ref.contentType,
+        etag: ref.etag,
+        checksum: ref.checksum,
+        offset: ref.offset,
+        size: ref.size,
+        updatedAt: ref.updatedAt,
+        metadata: ref.metadata,
+    });
+    return Object.keys(compacted).length > 0 ? compacted : undefined;
+}
+function createFileSyncTaskContext(sync) {
+    return {
+        signal: sync.signal,
+        now: sync.now,
+        metadata: sync.metadata,
+        sync,
+    };
+}
+function mergeArtifactRef(base, patch) {
+    if (!patch) {
+        return { ...base };
+    }
+    return compactArtifactRef({
+        ...base,
+        uri: patch.uri ?? base.uri,
+        local: patch.local ?? base.local,
+        contentType: patch.contentType ?? base.contentType,
+        etag: patch.etag ?? base.etag,
+        checksum: patch.checksum ?? base.checksum,
+        offset: patch.offset ?? base.offset,
+        size: patch.size ?? base.size,
+        updatedAt: patch.updatedAt ?? base.updatedAt,
+        metadata: compactMetadata({
+            ...base.metadata,
+            ...patch.metadata,
+        }),
+    });
+}
+function compactArtifactRef(ref) {
+    return compactMetadata(ref);
+}
+function compactMetadata(input) {
+    const output = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (value !== undefined && value !== null) {
+            output[key] = value;
+        }
+    }
+    return output;
+}
+function contentByteLength(content) {
+    return typeof content === 'string'
+        ? new TextEncoder().encode(content).byteLength
+        : content.byteLength;
+}
+function contentToText(content) {
+    return typeof content === 'string'
+        ? content
+        : new TextDecoder().decode(content);
+}
+function parseJsonLines(text) {
+    return text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => normalizeJsonRecord(JSON.parse(line)));
+}
+function normalizeJsonList(value, options) {
+    if (Array.isArray(value)) {
+        return value.map(normalizeJsonRecord);
+    }
+    if (options.allowSingleRecord !== false) {
+        return [normalizeJsonRecord(value)];
+    }
+    throw new Error('Expected a JSON array of records.');
+}
+function normalizeJsonRecord(value) {
+    if (!isJsonRecord(value)) {
+        throw new Error('Expected JSON records to be objects.');
+    }
+    return value;
+}
+function isJsonRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function looksLikeJsonLines(text) {
+    return /\r?\n/.test(text);
+}
+function hasWriteCondition(value) {
+    return Boolean(value?.etag) || typeof value?.offset === 'number';
+}
+function normalizeFileSyncWriteResult(value) {
+    return typeof value === 'object' && value !== null ? value : undefined;
+}
+function defaultFileToFileAction(writeMode) {
+    return writeMode === 'append' ? 'file.append' : 'file.copy';
+}
+function normalizeOperationSegment(value) {
+    return value.replace(/[:\s]+/g, '-');
+}

package/vendor/agent-runtime/dist/index.d.ts

@@ -1,6 +1,13 @@
 export * from './acp.js';
+export * from './agent-runtime.js';
 export * from './auto-mode.js';
 export * from './companion-model.js';
+export * from './control-plane.js';
+export * from './file-sync.js';
+export * from './reconciler.js';
 export * from './runtime.js';
 export * from './symphony.js';
+export * from './sync.js';
+export * from './thread-reconciler-controller.js';
 export * from './turn-controller.js';
+export * from './wake-scheduler.js';

package/vendor/agent-runtime/dist/index.js

@@ -1,6 +1,13 @@
 export * from './acp.js';
+export * from './agent-runtime.js';
 export * from './auto-mode.js';
 export * from './companion-model.js';
+export * from './control-plane.js';
+export * from './file-sync.js';
+export * from './reconciler.js';
 export * from './runtime.js';
 export * from './symphony.js';
+export * from './sync.js';
+export * from './thread-reconciler-controller.js';
 export * from './turn-controller.js';
+export * from './wake-scheduler.js';

package/vendor/agent-runtime/dist/reconciler.d.ts

@@ -0,0 +1,117 @@
+import type { AgentParticipantRole } from './turn-controller.js';
+export type ThreadPolicyKind = 'direct' | 'auto' | 'symphony' | 'open_group' | 'review';
+export type ThreadKind = 'main' | 'control' | 'worker' | 'review' | 'schedule' | 'schedule_run';
+export type ReconcilerEventType = 'message.appended' | 'input.required' | 'approval.required' | 'delivery.submitted' | 'delivery.completed' | 'delivery.failed' | 'schedule.tick' | 'worker.blocked' | 'change.requested' | 'issue.updated' | 'task.updated' | 'run.updated' | (string & {});
+export type ReconcilerActorRole = AgentParticipantRole | 'worker' | 'reviewer' | 'runtime' | 'scheduler' | 'tool' | 'assistant';
+export type WakeJobTargetRole = AgentParticipantRole | 'worker' | 'reviewer';
+export type WakeJobPriority = 'low' | 'normal' | 'high';
+export type WakeJobStatus = 'queued';
+export interface ReconcilerActorRef {
+    id?: string;
+    role?: ReconcilerActorRole;
+    label?: string;
+}
+export interface ReconcilerAgentRef {
+    id: string;
+    role?: WakeJobTargetRole;
+    aliases?: string[];
+    subscribed?: boolean;
+}
+export interface ThreadControlEvent<TData extends Record<string, unknown> = Record<string, unknown>> {
+    id?: string;
+    type: ReconcilerEventType;
+    chat?: string;
+    thread?: string;
+    resource?: string;
+    actor?: ReconcilerActorRef;
+    content?: string;
+    createdAt?: string;
+    data?: TData;
+}
+export interface ThreadPolicy {
+    kind: ThreadPolicyKind;
+    secretaryAgent?: string;
+    defaultAssistantAgent?: string;
+    assignedWorkerAgent?: string;
+    reviewerAgent?: string;
+    subscribedAgents?: string[];
+    agents?: ReconcilerAgentRef[];
+}
+export interface ThreadPlacement {
+    chat?: string;
+    thread: string;
+    kind: ThreadKind;
+    parentThread?: string;
+    rootThread?: string;
+    splitFrom?: string;
+    splitReason?: string;
+}
+export interface WakeJob {
+    id: string;
+    thread: string;
+    chat?: string;
+    targetAgent: string;
+    targetRole: WakeJobTargetRole;
+    trigger: ReconcilerEventType;
+    priority: WakeJobPriority;
+    status: WakeJobStatus;
+    reason: string;
+    sourceEventId?: string;
+    sourceEventType: ReconcilerEventType;
+    createdAt: string;
+}
+export interface ReconcileDecision {
+    id: string;
+    policyKind: ThreadPolicyKind;
+    event: ThreadControlEvent;
+    placement: ThreadPlacement;
+    wakeJobs: WakeJob[];
+    skippedReason?: string;
+    createdAt: string;
+}
+export interface WakeJobSummary {
+    id: string;
+    thread: string;
+    chat?: string;
+    targetAgent: string;
+    targetRole: WakeJobTargetRole;
+    trigger: ReconcilerEventType;
+    priority: WakeJobPriority;
+    status: WakeJobStatus;
+    reason: string;
+    sourceEventId?: string;
+    sourceEventType: ReconcilerEventType;
+    sourceResource?: string;
+    controlGate?: string;
+}
+export interface ReconcileDecisionSummary {
+    id: string;
+    policyKind: ThreadPolicyKind;
+    eventType: ReconcilerEventType;
+    thread: string;
+    chat?: string;
+    skippedReason?: string;
+    wakeJobs: WakeJobSummary[];
+    createdAt: string;
+}
+export interface ReconcileThreadEventInput {
+    policy: ThreadPolicyKind | ThreadPolicy;
+    event: ThreadControlEvent;
+    chat?: string;
+    thread?: string;
+    now?: Date;
+    randomId?: string;
+}
+export interface ThreadReconciler {
+    readonly policy: ThreadPolicy;
+    reconcile(event: ThreadControlEvent, options?: Omit<ReconcileThreadEventInput, 'policy' | 'event'>): ReconcileDecision;
+}
+export declare function createThreadReconciler(policy: ThreadPolicyKind | ThreadPolicy): ThreadReconciler;
+export declare function reconcileThreadEvent(input: ReconcileThreadEventInput): ReconcileDecision;
+export declare function summarizeReconcileDecision(decision: ReconcileDecision): ReconcileDecisionSummary;
+export declare function resolveThreadPlacement(input: {
+    event: ThreadControlEvent;
+    chat?: string;
+    thread?: string;
+    randomId?: string;
+}): ThreadPlacement;