@xfey/tutti 0.1.0

package/dist/collaboration-state/messages.js

@@ -0,0 +1,371 @@
+import { createMessageId } from "@tutti/shared/ids";
+import { clampLimit, decodeCursor, messageCursor, nowIso, parseJson, stringifyJson, } from "./serialization.js";
+import { recordReadNotificationEvent } from "./read-state.js";
+function readClarificationCardForMessage(db, messageId) {
+    const row = db
+        .prepare(`
+        SELECT
+          clarification_rounds.*,
+          clarification_threads.current_round_id AS thread_current_round_id
+        FROM clarification_rounds
+        JOIN clarification_threads
+          ON clarification_threads.id = clarification_rounds.clarification_thread_id
+        WHERE clarification_rounds.card_message_id = ?
+      `)
+        .get(messageId);
+    if (row === undefined) {
+        return undefined;
+    }
+    const requestPayload = parseJson(row.request_payload_json, {
+        summary: "",
+        request: "",
+    });
+    const card = {
+        thread_id: row.clarification_thread_id,
+        round_id: row.id,
+        summary: requestPayload.summary,
+        status: row.status,
+        is_current_round: row.thread_current_round_id === row.id,
+    };
+    if (requestPayload.title !== undefined) {
+        card.title = requestPayload.title;
+    }
+    return card;
+}
+export function mapMessageRow(row, db) {
+    const author = {
+        kind: row.author_kind,
+    };
+    if (row.author_ref !== null) {
+        author.ref = row.author_ref;
+    }
+    if (row.author_display_name !== null) {
+        author.display_name = row.author_display_name;
+    }
+    if (row.author_avatar_json !== null) {
+        const avatar = parseJson(row.author_avatar_json, undefined);
+        if (avatar !== undefined) {
+            author.avatar = avatar;
+        }
+    }
+    const message = {
+        id: row.id,
+        scope: row.scope_kind === "main_chat"
+            ? { kind: "main_chat" }
+            : {
+                kind: "clarification_round",
+                clarification_round_ref: row.clarification_round_id ?? "",
+            },
+        author,
+        message_kind: row.message_kind,
+        body: row.body,
+        created_at: row.created_at,
+    };
+    if (row.refs_json !== null) {
+        message.refs = parseJson(row.refs_json, {});
+    }
+    if (db !== undefined && row.message_kind === "clarification_card") {
+        const clarificationCard = readClarificationCardForMessage(db, row.id);
+        if (clarificationCard !== undefined) {
+            message.clarification_card = clarificationCard;
+        }
+    }
+    return message;
+}
+export function createMainChatMessage(db, input) {
+    const now = (input.now ?? (() => new Date()))().toISOString();
+    const id = createMessageId();
+    db.prepare(`
+      INSERT INTO messages (
+        id,
+        scope_kind,
+        author_kind,
+        author_ref,
+        author_display_name,
+        author_avatar_json,
+        message_kind,
+        body,
+        refs_json,
+        created_at
+      )
+      VALUES (?, 'main_chat', ?, ?, ?, ?, 'user_text', ?, ?, ?)
+    `).run(id, input.author.kind, input.author.ref ?? null, input.author.display_name ?? null, input.author.avatar === undefined ? null : stringifyJson(input.author.avatar), input.body, input.refs === undefined ? null : stringifyJson(input.refs), now);
+    recordReadNotificationEvent(db, {
+        scope: "chat",
+        source_kind: "message",
+        source_ref: id,
+        actor: {
+            kind: input.author.kind,
+            ...(input.author.ref === undefined ? {} : { ref: input.author.ref }),
+        },
+        occurred_at: now,
+    });
+    const message = {
+        id,
+        scope: { kind: "main_chat" },
+        author: input.author,
+        message_kind: "user_text",
+        body: input.body,
+        created_at: now,
+    };
+    if (input.refs !== undefined) {
+        message.refs = input.refs;
+    }
+    return message;
+}
+export function createMainChatSystemMessage(db, input) {
+    const createdAt = nowIso(input.now);
+    const id = createMessageId();
+    db.prepare(`
+      INSERT INTO messages (
+        id,
+        scope_kind,
+        author_kind,
+        message_kind,
+        body,
+        refs_json,
+        created_at
+      )
+      VALUES (?, 'main_chat', 'system', 'system_notice', ?, ?, ?)
+    `).run(id, input.body, input.refs === undefined ? null : stringifyJson(input.refs), createdAt);
+    recordReadNotificationEvent(db, {
+        scope: "chat",
+        source_kind: "message",
+        source_ref: id,
+        actor: { kind: "system" },
+        occurred_at: createdAt,
+    });
+    const message = {
+        id,
+        scope: { kind: "main_chat" },
+        author: { kind: "system" },
+        message_kind: "system_notice",
+        body: input.body,
+        created_at: createdAt,
+    };
+    if (input.refs !== undefined) {
+        message.refs = input.refs;
+    }
+    return message;
+}
+export function createMainChatAgentMessage(db, input) {
+    const createdAt = nowIso(input.now);
+    const id = createMessageId();
+    db.prepare(`
+      INSERT INTO messages (
+        id,
+        scope_kind,
+        author_kind,
+        author_ref,
+        author_display_name,
+        message_kind,
+        body,
+        refs_json,
+        created_at
+      )
+      VALUES (?, 'main_chat', 'agent', 'tutti', 'Tutti', 'agent_text', ?, ?, ?)
+    `).run(id, input.body, input.refs === undefined ? null : stringifyJson(input.refs), createdAt);
+    recordReadNotificationEvent(db, {
+        scope: "chat",
+        source_kind: "message",
+        source_ref: id,
+        actor: { kind: "agent", ref: "tutti" },
+        occurred_at: createdAt,
+    });
+    const message = {
+        id,
+        scope: { kind: "main_chat" },
+        author: { kind: "agent", ref: "tutti", display_name: "Tutti" },
+        message_kind: "agent_text",
+        body: input.body,
+        created_at: createdAt,
+    };
+    if (input.refs !== undefined) {
+        message.refs = input.refs;
+    }
+    return message;
+}
+export function readMessageProjectionById(db, messageId) {
+    const row = db
+        .prepare(`
+        SELECT *
+        FROM messages
+        WHERE id = ?
+      `)
+        .get(messageId);
+    return row === undefined ? null : mapMessageRow(row, db);
+}
+export function hasMainChatWorklistFeedbackMessage(db, feedbackKey) {
+    const row = db
+        .prepare(`
+        SELECT 1 AS exists_flag
+        FROM messages
+        WHERE scope_kind = 'main_chat'
+          AND json_extract(refs_json, '$.worklist_feedback.feedback_key') = ?
+        LIMIT 1
+      `)
+        .get(feedbackKey);
+    return row !== undefined;
+}
+export function readCompletedWorklistFeedbackTaskIds(db) {
+    const rows = db
+        .prepare(`
+        SELECT refs_json
+        FROM messages
+        WHERE scope_kind = 'main_chat'
+          AND refs_json IS NOT NULL
+          AND json_extract(refs_json, '$.worklist_feedback.status') = 'completed'
+      `)
+        .all();
+    const taskIds = new Set();
+    for (const row of rows) {
+        const refs = parseJson(row.refs_json, {});
+        const feedback = refs.worklist_feedback;
+        if (feedback?.status !== "completed" ||
+            feedback.reason !== "all_tasks_done" ||
+            !Array.isArray(feedback.items)) {
+            continue;
+        }
+        for (const item of feedback.items) {
+            if (typeof item === "object" &&
+                item !== null &&
+                !Array.isArray(item) &&
+                item.status === "done" &&
+                typeof item.task_id === "string") {
+                taskIds.add(item.task_id);
+            }
+        }
+    }
+    return taskIds;
+}
+export function readMainChatMessageWindow(db, options = {}) {
+    const limit = clampLimit(options.limit);
+    const before = decodeCursor(options.before);
+    const after = decodeCursor(options.after);
+    if (before !== null && after !== null) {
+        throw new Error("before and after cursors cannot be used together");
+    }
+    let rows;
+    let hasOlder = false;
+    let hasNewer = false;
+    if (before !== null) {
+        rows = db
+            .prepare(`
+          SELECT *
+          FROM messages
+          WHERE scope_kind = 'main_chat'
+            AND (created_at < ? OR (created_at = ? AND id < ?))
+          ORDER BY created_at DESC, id DESC
+          LIMIT ?
+        `)
+            .all(before.created_at, before.created_at, before.id, limit + 1);
+        hasOlder = rows.length > limit;
+        hasNewer = true;
+        rows = rows.slice(0, limit).reverse();
+    }
+    else if (after !== null) {
+        rows = db
+            .prepare(`
+          SELECT *
+          FROM messages
+          WHERE scope_kind = 'main_chat'
+            AND (created_at > ? OR (created_at = ? AND id > ?))
+          ORDER BY created_at ASC, id ASC
+          LIMIT ?
+        `)
+            .all(after.created_at, after.created_at, after.id, limit + 1);
+        hasNewer = rows.length > limit;
+        hasOlder = true;
+        rows = rows.slice(0, limit);
+    }
+    else if (options.anchor === "start") {
+        rows = db
+            .prepare(`
+          SELECT *
+          FROM messages
+          WHERE scope_kind = 'main_chat'
+          ORDER BY created_at ASC, id ASC
+          LIMIT ?
+        `)
+            .all(limit + 1);
+        hasNewer = rows.length > limit;
+        rows = rows.slice(0, limit);
+    }
+    else {
+        rows = db
+            .prepare(`
+          SELECT *
+          FROM messages
+          WHERE scope_kind = 'main_chat'
+          ORDER BY created_at DESC, id DESC
+          LIMIT ?
+        `)
+            .all(limit + 1);
+        hasOlder = rows.length > limit;
+        rows = rows.slice(0, limit).reverse();
+    }
+    const items = rows.map((row) => mapMessageRow(row, db));
+    const first = items[0];
+    const last = items.at(-1);
+    const window = {
+        has_older: hasOlder,
+        has_newer: hasNewer,
+        limit,
+    };
+    if (hasOlder && first !== undefined) {
+        window.older_cursor = messageCursor(first);
+    }
+    if (hasNewer && last !== undefined) {
+        window.newer_cursor = messageCursor(last);
+    }
+    return { items, window };
+}
+export function readMainChatMessagesAfter(db, options) {
+    const limit = clampLimit(options.limit);
+    const rows = db
+        .prepare(`
+        SELECT *
+        FROM messages
+        WHERE scope_kind = 'main_chat'
+          AND created_at > ?
+        ORDER BY created_at ASC, id ASC
+        LIMIT ?
+      `)
+        .all(options.after_created_at, limit);
+    return rows.map((row) => mapMessageRow(row, db));
+}
+export function readMainChatMessagesAfterCursor(db, options) {
+    const limit = clampLimit(options.limit);
+    const rows = db
+        .prepare(`
+        SELECT *
+        FROM messages
+        WHERE scope_kind = 'main_chat'
+          AND (
+            created_at > ?
+            OR (created_at = ? AND id > ?)
+          )
+        ORDER BY created_at ASC, id ASC
+        LIMIT ?
+      `)
+        .all(options.after_created_at, options.after_created_at, options.after_id, limit);
+    return rows.map((row) => mapMessageRow(row, db));
+}
+export function readMainChatMessagesBeforeCursor(db, options) {
+    const limit = clampLimit(options.limit);
+    const rows = db
+        .prepare(`
+        SELECT *
+        FROM messages
+        WHERE scope_kind = 'main_chat'
+          AND (
+            created_at < ?
+            OR (created_at = ? AND id < ?)
+          )
+        ORDER BY created_at DESC, id DESC
+        LIMIT ?
+      `)
+        .all(options.before_created_at, options.before_created_at, options.before_id, limit);
+    return rows.reverse().map((row) => mapMessageRow(row, db));
+}
+//# sourceMappingURL=messages.js.map

package/dist/collaboration-state/read-state.d.ts

@@ -0,0 +1,7 @@
+import type { ReadStateSummaryProjection } from "@tutti/shared/schemas/api";
+import type { SqliteDatabase } from "../store/index.js";
+import type { MarkReadStateScopeInput, MarkReadStateScopeResult, ReadReadStateSummaryInput, RecordReadNotificationEventInput } from "./types.js";
+export declare function recordReadNotificationEvent(db: SqliteDatabase, input: RecordReadNotificationEventInput): number;
+export declare function readReadStateSummary(db: SqliteDatabase, input: ReadReadStateSummaryInput): ReadStateSummaryProjection;
+export declare function markReadStateScope(db: SqliteDatabase, input: MarkReadStateScopeInput): MarkReadStateScopeResult;
+//# sourceMappingURL=read-state.d.ts.map

package/dist/collaboration-state/read-state.js

@@ -0,0 +1,136 @@
+import { nowIso } from "./serialization.js";
+const READ_STATE_SCOPES = [
+    "chat",
+    "worklist",
+    "references",
+    "skills",
+];
+function latestEventForScope(db, scope) {
+    return (db
+        .prepare(`
+          SELECT event_cursor, occurred_at
+          FROM read_notification_events
+          WHERE scope = ?
+          ORDER BY event_cursor DESC
+          LIMIT 1
+        `)
+        .get(scope) ?? null);
+}
+function readCursorRow(db, accountRef, scope) {
+    return (db
+        .prepare(`
+          SELECT *
+          FROM read_state_cursors
+          WHERE account_ref = ?
+            AND scope = ?
+        `)
+        .get(accountRef, scope) ?? null);
+}
+function fallbackReadCursorForSession(db, scope, sessionCreatedAt) {
+    return (db
+        .prepare(`
+          SELECT MAX(event_cursor) AS read_event_cursor
+          FROM read_notification_events
+          WHERE scope = ?
+            AND occurred_at <= ?
+        `)
+        .get(scope, sessionCreatedAt)?.read_event_cursor ?? 0);
+}
+function hasUnreadEvents(input) {
+    const row = input.db
+        .prepare(`
+        SELECT 1 AS found
+        FROM read_notification_events
+        WHERE scope = ?
+          AND event_cursor > ?
+          AND NOT (
+            scope = 'chat'
+            AND actor_kind = 'human'
+            AND actor_ref = ?
+          )
+        LIMIT 1
+      `)
+        .get(input.scope, input.read_event_cursor, input.account_ref);
+    return row !== undefined;
+}
+function readEffectiveCursor(input) {
+    const row = readCursorRow(input.db, input.account_ref, input.scope);
+    if (row !== null) {
+        return row.read_event_cursor;
+    }
+    return fallbackReadCursorForSession(input.db, input.scope, input.session_created_at);
+}
+export function recordReadNotificationEvent(db, input) {
+    const createdAt = input.created_at ?? input.occurred_at;
+    const result = db
+        .prepare(`
+        INSERT INTO read_notification_events (
+          scope,
+          source_kind,
+          source_ref,
+          actor_kind,
+          actor_ref,
+          occurred_at,
+          created_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `)
+        .run(input.scope, input.source_kind, input.source_ref, input.actor?.kind ?? null, input.actor?.ref ?? null, input.occurred_at, createdAt);
+    return Number(result.lastInsertRowid);
+}
+export function readReadStateSummary(db, input) {
+    const generatedAt = nowIso(input.now);
+    const scopes = Object.fromEntries(READ_STATE_SCOPES.map((scope) => {
+        const latest = latestEventForScope(db, scope);
+        const latestCursor = latest?.event_cursor ?? 0;
+        const readCursor = Math.min(readEffectiveCursor({
+            db,
+            account_ref: input.account_ref,
+            scope,
+            session_created_at: input.session_created_at,
+        }), latestCursor);
+        const projection = {
+            scope,
+            latest_event_cursor: latestCursor,
+            read_event_cursor: readCursor,
+            has_unread: hasUnreadEvents({
+                db,
+                scope,
+                account_ref: input.account_ref,
+                read_event_cursor: readCursor,
+            }),
+        };
+        if (latest !== null) {
+            projection.updated_at = latest.occurred_at;
+        }
+        return [scope, projection];
+    }));
+    return {
+        generated_at: generatedAt,
+        scopes,
+    };
+}
+export function markReadStateScope(db, input) {
+    const updatedAt = nowIso(input.now);
+    const latestCursor = latestEventForScope(db, input.scope)?.event_cursor ?? 0;
+    const requestedCursor = input.up_to_event_cursor ?? latestCursor;
+    const readCursor = Math.min(Math.max(Math.trunc(requestedCursor), 0), latestCursor);
+    db.prepare(`
+      INSERT INTO read_state_cursors (
+        account_ref,
+        scope,
+        read_event_cursor,
+        read_at,
+        updated_at
+      )
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(account_ref, scope) DO UPDATE SET
+        read_event_cursor = max(read_state_cursors.read_event_cursor, excluded.read_event_cursor),
+        read_at = excluded.read_at,
+        updated_at = excluded.updated_at
+    `).run(input.account_ref, input.scope, readCursor, updatedAt, updatedAt);
+    return {
+        read_state: readReadStateSummary(db, input),
+    };
+}
+//# sourceMappingURL=read-state.js.map

package/dist/collaboration-state/recovery.d.ts

@@ -0,0 +1,6 @@
+import { type SqliteDatabase } from "../store/index.js";
+import type { RecoverStaleRunningTasksResult } from "./types.js";
+export declare function recoverStaleRunningTasksAsFailed(db: SqliteDatabase, input?: {
+    now?: () => Date;
+}): RecoverStaleRunningTasksResult;
+//# sourceMappingURL=recovery.d.ts.map

package/dist/collaboration-state/recovery.js

@@ -0,0 +1,125 @@
+import { createEventRef, createRunResultId, } from "@tutti/shared/ids";
+import { withHostStoreTransaction } from "../store/index.js";
+import { nowIso, parseJson, stringifyJson } from "./serialization.js";
+import { mapRunResultRow } from "./run-results.js";
+import { readTaskDetailProjection } from "./task-details.js";
+import { readTaskProjection } from "./worklist.js";
+import { recordReadNotificationEvent } from "./read-state.js";
+function inferRecoveryRunLineage(tx, taskRow) {
+    if (taskRow.latest_run_result_id === null) {
+        return { attempt: 1, kind: "initial" };
+    }
+    const latestRunResult = tx
+        .prepare("SELECT * FROM run_results WHERE id = ?")
+        .get(taskRow.latest_run_result_id);
+    if (latestRunResult === undefined) {
+        return { attempt: 1, kind: "initial" };
+    }
+    const parentLineage = parseJson(latestRunResult.run_lineage_json, {
+        attempt: 1,
+        kind: "initial",
+    });
+    const runKind = latestRunResult.result_kind === "needs_human" ? "continuation" : "retry";
+    return {
+        attempt: parentLineage.attempt + 1,
+        kind: runKind,
+        parent_activity_ref: latestRunResult.activity_ref,
+        root_activity_ref: parentLineage.root_activity_ref ?? latestRunResult.activity_ref,
+    };
+}
+export function recoverStaleRunningTasksAsFailed(db, input = {}) {
+    return withHostStoreTransaction(db, (tx) => {
+        const recoveredAt = nowIso(input.now);
+        const staleTasks = tx
+            .prepare(`
+          SELECT *
+          FROM tasks
+          WHERE status = 'running'
+            AND current_activity_ref IS NOT NULL
+          ORDER BY updated_at ASC, id ASC
+        `)
+            .all();
+        const recoveredRuns = [];
+        for (const taskRow of staleTasks) {
+            const activityRef = taskRow.current_activity_ref;
+            const runResultId = createRunResultId();
+            const sourceEventRef = createEventRef();
+            const runLineage = inferRecoveryRunLineage(tx, taskRow);
+            const resultJson = {
+                result_kind: "failed",
+                summary: "Run was interrupted by host restart and marked failed during startup recovery.",
+                error_code: "run_interrupted_by_restart",
+                retryable: true,
+                promotion: {
+                    status: "not_attempted",
+                    reason_code: "startup_recovery_interrupted",
+                    summary: "Run did not reach promotion before the host process stopped.",
+                },
+            };
+            const detailResult = {
+                latest_run_result_id: runResultId,
+                result_kind: "failed",
+                run_lineage: runLineage,
+                summary: resultJson.summary,
+                error_code: resultJson.error_code,
+                retryable: resultJson.retryable,
+                promotion: resultJson.promotion,
+                updated_at: recoveredAt,
+            };
+            tx.prepare(`
+          INSERT INTO run_results (
+            id,
+            activity_ref,
+            task_id,
+            source_event_ref,
+            run_lineage_json,
+            result_kind,
+            result_json,
+            created_at
+          )
+          VALUES (?, ?, ?, ?, ?, 'failed', ?, ?)
+        `).run(runResultId, activityRef, taskRow.id, sourceEventRef, stringifyJson(runLineage), stringifyJson(resultJson), recoveredAt);
+            tx.prepare(`
+          UPDATE tasks
+          SET status = 'failed',
+              current_activity_ref = NULL,
+              latest_run_result_id = ?,
+              updated_at = ?
+          WHERE id = ?
+            AND status = 'running'
+        `).run(runResultId, recoveredAt, taskRow.id);
+            tx.prepare(`
+          UPDATE task_details
+          SET result_json = ?,
+              frozen_contract_since_activity_ref = COALESCE(
+                frozen_contract_since_activity_ref,
+                ?
+              ),
+              updated_at = ?
+          WHERE task_id = ?
+        `).run(stringifyJson(detailResult), activityRef, recoveredAt, taskRow.id);
+            recordReadNotificationEvent(tx, {
+                scope: "worklist",
+                source_kind: "startup_recovery",
+                source_ref: runResultId,
+                occurred_at: recoveredAt,
+            });
+            const runResultRow = tx
+                .prepare("SELECT * FROM run_results WHERE id = ?")
+                .get(runResultId);
+            const task = readTaskProjection(tx, taskRow.id);
+            const taskDetail = readTaskDetailProjection(tx, taskRow.id);
+            if (runResultRow === undefined || task === null || taskDetail === null) {
+                throw new Error("Startup recovery did not produce readable task projections");
+            }
+            recoveredRuns.push({
+                activity_ref: activityRef,
+                run_result: mapRunResultRow(runResultRow),
+                task,
+                task_detail: taskDetail,
+            });
+        }
+        return { recovered_runs: recoveredRuns };
+    });
+}
+//# sourceMappingURL=recovery.js.map

package/dist/collaboration-state/run-recording.d.ts

@@ -0,0 +1,5 @@
+import { type SqliteDatabase } from "../store/index.js";
+import type { RecordRunNeedsHumanResultInput, RecordRunNeedsHumanResultResult, RecordRunResultInput, RecordRunResultResult } from "./types.js";
+export declare function recordRunResult(db: SqliteDatabase, input: RecordRunResultInput): RecordRunResultResult;
+export declare function recordRunNeedsHumanResult(db: SqliteDatabase, input: RecordRunNeedsHumanResultInput): RecordRunNeedsHumanResultResult;
+//# sourceMappingURL=run-recording.d.ts.map