@litfamily/litopencode 1.0.0

package/dist/bounded-authority-hooks.js

@@ -0,0 +1,157 @@
+import { LifecycleConflictError, LifecycleSafetyError, createBoundedAuthorityLifecycle, parseFencedProgress } from "./bounded-authority.js";
+export function parseStartWorkLifecycleDirective(text, options = {}) {
+    if (typeof text !== "string" || text.length > 16_384)
+        return undefined;
+    const candidate = options.chat === true
+        ? /^start-work (init|resume|cancel|complete|status)(?: (\{[^\r\n]*\}))?$/u.exec(text.trim())
+        : /^(init|resume|cancel|complete|status)(?: (\{[^\r\n]*\}))?$/u.exec(text.trim());
+    if (candidate === null)
+        return undefined;
+    if (candidate[1] === "status" && candidate[2] === undefined)
+        return { action: "status", payload: {} };
+    if (candidate[2] === undefined)
+        return undefined;
+    let payload;
+    try {
+        payload = JSON.parse(candidate[2]);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof payload !== "object" || payload === null || Array.isArray(payload))
+        return undefined;
+    return { action: candidate[1], payload: payload };
+}
+export async function applyTrustedStartWorkDirective(projectRoot, sessionID, directive, options = {}) {
+    if (directive.action !== "status" && directive.payload.schemaVersion !== 3) {
+        throw new LifecycleSafetyError("Trusted lifecycle directives must explicitly declare schemaVersion 3.");
+    }
+    const lifecycle = createBoundedAuthorityLifecycle(projectRoot, options);
+    let state;
+    switch (directive.action) {
+        case "status":
+            state = await lifecycle.read();
+            break;
+        case "init":
+            state = (await lifecycle.init({
+                ...directive.payload,
+                schemaVersion: 3,
+                sessionID,
+                trustedUser: true
+            })).state;
+            break;
+        case "resume":
+            state = (await lifecycle.resume({
+                ...directive.payload,
+                schemaVersion: 3,
+                sessionID,
+                trustedUser: true
+            })).state;
+            break;
+        case "cancel":
+            state = (await lifecycle.cancel({
+                ...directive.payload,
+                schemaVersion: 3,
+                sessionID,
+                trustedUser: true
+            })).state;
+            break;
+        case "complete":
+            state = (await lifecycle.complete({
+                ...directive.payload,
+                schemaVersion: 3,
+                sessionID,
+                trustedUser: true
+            })).state;
+            break;
+    }
+    const receipt = {
+        schemaVersion: 3,
+        kind: "bounded-authority-lifecycle",
+        action: directive.action,
+        workId: state.workId,
+        revision: state.revision,
+        status: state.status,
+        pendingBoundary: state.pendingBoundary === null ? null : {
+            id: state.pendingBoundary.id,
+            action: state.pendingBoundary.action
+        }
+    };
+    return {
+        text: `<bounded-authority-lifecycle>\n${JSON.stringify(receipt)}\n</bounded-authority-lifecycle>`,
+        status: state.status,
+        revision: state.revision,
+        workId: state.workId
+    };
+}
+async function assistantMessage(client, projectRoot, sessionID, messageID) {
+    try {
+        const result = await client.session.message({
+            path: { id: sessionID, messageID },
+            query: { directory: projectRoot }
+        });
+        const info = result.data?.info;
+        return typeof info === "object" && info !== null && info.role === "assistant";
+    }
+    catch {
+        return false;
+    }
+}
+export function createBoundedAuthorityEventHook(projectRoot, client, options = {}) {
+    const lifecycle = createBoundedAuthorityLifecycle(projectRoot, options);
+    return async ({ event }) => {
+        if (client === undefined || event.type !== "message.part.updated")
+            return;
+        const part = event.properties.part;
+        if (part.type !== "text" || typeof part.text !== "string")
+            return;
+        let progress;
+        try {
+            progress = parseFencedProgress(part.text);
+        }
+        catch {
+            return;
+        }
+        if (progress === undefined)
+            return;
+        if (!(await assistantMessage(client, projectRoot, part.sessionID, part.messageID)))
+            return;
+        try {
+            const recorded = await lifecycle.recordProgress({
+                ...progress,
+                sessionID: part.sessionID,
+                messageID: part.messageID,
+                partID: part.id
+            });
+            if (recorded.dispatchRequired !== true ||
+                recorded.continuation === undefined ||
+                recorded.continuationMessageID === undefined)
+                return;
+            try {
+                await client.session.promptAsync({
+                    path: { id: part.sessionID },
+                    query: { directory: projectRoot },
+                    body: {
+                        messageID: recorded.continuationMessageID,
+                        parts: [{ type: "text", text: recorded.continuation }]
+                    }
+                });
+            }
+            catch {
+                return;
+            }
+            await lifecycle.markContinuationSent({
+                workId: recorded.state.workId,
+                sessionID: recorded.state.sessionID,
+                revision: recorded.state.revision,
+                messageID: part.messageID,
+                partID: part.id
+            });
+        }
+        catch (error) {
+            if (error instanceof LifecycleConflictError || error instanceof LifecycleSafetyError)
+                return;
+            throw error;
+        }
+    };
+}

package/dist/bounded-authority.d.ts

@@ -0,0 +1,184 @@
+import { type RuntimePaths } from "./state.ts";
+export declare const boundedAuthoritySchemaVersion: 3;
+export type SemanticAuthorityAction = "read" | "write" | "execute";
+export type BoundedWorkStatus = "active" | "paused" | "cancelled" | "completed";
+export type AuthorityGrant = {
+    readonly action: SemanticAuthorityAction;
+    readonly root: string;
+};
+export type AuthorityBoundary = AuthorityGrant & {
+    readonly id: string;
+};
+export type ConsumedAuthorityGrant = AuthorityGrant & {
+    readonly boundaryId: string;
+    readonly consumedAtRevision: number;
+    readonly sessionID: string;
+};
+export type LifecycleHistoryEntry = {
+    readonly revision: number;
+    readonly type: LifecycleEventType;
+    readonly requestId: string;
+    readonly timestamp: string;
+};
+export type LifecycleReceipt = {
+    readonly requestId: string;
+    readonly operation: LifecycleOperation;
+    readonly revision: number;
+    readonly fingerprint: string;
+};
+export type ProgressCheckpoint = {
+    readonly digest: string;
+    readonly progressId: string;
+    readonly messageID: string;
+    readonly partID: string;
+    readonly continuation: string;
+    readonly continuationMessageID: string;
+    readonly revision: number;
+    readonly continuationSent: boolean;
+};
+export type BoundedAuthorityState = {
+    readonly schemaVersion: 3;
+    readonly workId: string;
+    readonly sessionID: string;
+    readonly revision: number;
+    readonly status: BoundedWorkStatus;
+    readonly worktree: string;
+    readonly plan: {
+        readonly path: string;
+        readonly sha256: string;
+        readonly bytes: number;
+    };
+    readonly authority: {
+        readonly grants: readonly AuthorityGrant[];
+        readonly consumed: readonly ConsumedAuthorityGrant[];
+    };
+    readonly pendingBoundary: AuthorityBoundary | null;
+    readonly history: readonly LifecycleHistoryEntry[];
+    readonly receipts: readonly LifecycleReceipt[];
+    readonly progress: {
+        readonly last: ProgressCheckpoint | null;
+        readonly recentDigests: readonly string[];
+    };
+    readonly createdAt: string;
+    readonly updatedAt: string;
+};
+export type LifecycleOperation = "init" | "pause" | "resume" | "cancel" | "complete" | "progress" | "continuation-acknowledgement";
+export type LifecycleEventType = "work.initialized" | "work.paused" | "work.resumed" | "work.cancelled" | "work.completed" | "work.progressed" | "work.continuation-acknowledged";
+export type LifecycleMutationResult = {
+    readonly outcome: "applied" | "replayed" | "already-authorized";
+    readonly state: BoundedAuthorityState;
+};
+export type ProgressRecordResult = {
+    readonly outcome: "continued" | "same-turn-replay" | "unchanged" | "stale" | "paused";
+    readonly state: BoundedAuthorityState;
+    readonly continuation?: string;
+    readonly dispatchRequired?: boolean;
+    readonly continuationMessageID?: string;
+};
+export type FencedProgress = {
+    readonly schemaVersion: 3;
+    readonly workId: string;
+    readonly revision: number;
+    readonly progressId: string;
+    readonly summary: string;
+    readonly boundary?: {
+        readonly action: string;
+        readonly root: string;
+    };
+};
+export type BoundedContextFile = {
+    readonly kind: "file";
+    readonly path: string;
+    readonly bytes: number;
+    readonly sha256: string;
+    readonly text: string;
+};
+export type BoundedAuthorityOptions = {
+    readonly maxEvents?: number;
+    readonly maxHistory?: number;
+    readonly maxReceipts?: number;
+    readonly maxContextBytes?: number;
+    readonly lockTimeoutMs?: number;
+    readonly staleLockMs?: number;
+    readonly now?: () => Date;
+};
+export type LifecycleInitRequest = {
+    readonly schemaVersion: 3;
+    readonly requestId: string;
+    readonly sessionID: string;
+    readonly trustedUser: boolean;
+    readonly expectedRevision: number;
+    readonly planPath: string;
+    readonly worktree: string | null;
+    readonly authorized: boolean;
+    readonly authority: readonly {
+        readonly action: string;
+        readonly root: string;
+    }[];
+};
+export type LifecycleBoundaryRequest = {
+    readonly schemaVersion: 3;
+    readonly requestId: string;
+    readonly workId: string;
+    readonly sessionID: string;
+    readonly expectedRevision: number;
+    readonly boundary: {
+        readonly action: string;
+        readonly root: string;
+    };
+};
+export type LifecycleResumeRequest = {
+    readonly schemaVersion: 3;
+    readonly requestId: string;
+    readonly workId: string;
+    readonly sessionID: string;
+    readonly expectedRevision: number;
+    readonly trustedUser: boolean;
+    readonly grant: {
+        readonly action: string;
+        readonly root: string;
+    };
+};
+export type LifecycleTerminalRequest = {
+    readonly schemaVersion: 3;
+    readonly requestId: string;
+    readonly workId: string;
+    readonly sessionID: string;
+    readonly expectedRevision: number;
+    readonly trustedUser: boolean;
+};
+export type ProgressRecordRequest = FencedProgress & {
+    readonly sessionID: string;
+    readonly messageID: string;
+    readonly partID: string;
+};
+export type BoundedAuthorityLifecycle = {
+    readonly init: (request: LifecycleInitRequest) => Promise<LifecycleMutationResult>;
+    readonly pause: (request: LifecycleBoundaryRequest) => Promise<LifecycleMutationResult>;
+    readonly resume: (request: LifecycleResumeRequest) => Promise<LifecycleMutationResult>;
+    readonly cancel: (request: LifecycleTerminalRequest) => Promise<LifecycleMutationResult>;
+    readonly complete: (request: LifecycleTerminalRequest) => Promise<LifecycleMutationResult>;
+    readonly recordProgress: (request: ProgressRecordRequest) => Promise<ProgressRecordResult>;
+    readonly markContinuationSent: (request: {
+        readonly workId: string;
+        readonly sessionID: string;
+        readonly revision: number;
+        readonly messageID: string;
+        readonly partID: string;
+    }) => Promise<BoundedAuthorityState>;
+    readonly read: () => Promise<BoundedAuthorityState>;
+    readonly reconcile: () => Promise<BoundedAuthorityState>;
+};
+export declare class LifecycleConflictError extends Error {
+    constructor(message: string);
+}
+export declare class LifecycleSafetyError extends Error {
+    constructor(message: string);
+}
+export declare function readBoundedContextFile(filePath: string, options: {
+    readonly root: string;
+    readonly maxBytes?: number;
+}): Promise<BoundedContextFile>;
+export declare function parseFencedProgress(text: string): FencedProgress | undefined;
+export declare function createBoundedAuthorityLifecycle(projectRoot: string, rawOptions?: BoundedAuthorityOptions): BoundedAuthorityLifecycle;
+export declare function lifecyclePaths(projectRoot: string): Pick<RuntimePaths, "lifecycleStateFile" | "lifecycleEventsFile" | "lifecycleLockDir">;