@xfey/tutti 0.1.0

package/dist/server-shell/http/routes/project-api/read-state-routes.js

@@ -0,0 +1,82 @@
+import { MarkReadBodySchema, MarkReadResponseSchema, ReadStateSummaryProjectionSchema, } from "@tutti/shared/schemas/api";
+import { markReadStateScope, readReadStateSummary, } from "../../../../collaboration-state/index.js";
+import { executeIdempotentCommand } from "../../../command-idempotency/index.js";
+import { HOST_PROJECT_API_BASE_PATH } from "./constants.js";
+import { readStateInvalidates } from "./invalidations.js";
+import { requireHostProjectSession, requireProjectStore, } from "./session-requirements.js";
+export function registerReadStateRoutes(app, { options, workspaceEvents, }) {
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/read-state`, {
+        schema: {
+            response: {
+                200: ReadStateSummaryProjectionSchema,
+            },
+        },
+    }, (request) => {
+        const session = requireHostProjectSession(request, options);
+        const store = requireProjectStore(options);
+        return readReadStateSummary(store.db, {
+            account_ref: session.account.account_ref,
+            session_created_at: session.client_session.connected_at,
+            ...(options.now === undefined ? {} : { now: options.now }),
+        });
+    });
+    app.post(`${HOST_PROJECT_API_BASE_PATH}/read-state/mark-read`, {
+        schema: {
+            body: MarkReadBodySchema,
+            response: {
+                200: MarkReadResponseSchema,
+            },
+        },
+    }, (request) => {
+        const session = requireHostProjectSession(request, options);
+        const store = requireProjectStore(options);
+        const payload = request.body.payload;
+        const execution = executeIdempotentCommand({
+            db: store.db,
+            command_id: request.body.command_id,
+            command_name: "read_state.mark_read",
+            target_ref: payload.scope,
+            payload: {
+                account_ref: session.account.account_ref,
+                scope: payload.scope,
+                ...(payload.up_to_event_cursor === undefined
+                    ? {}
+                    : { up_to_event_cursor: payload.up_to_event_cursor }),
+            },
+            ...(options.now === undefined ? {} : { now: options.now }),
+            execute: (tx) => ({
+                disposition: { kind: "marked" },
+                result: markReadStateScope(tx, {
+                    account_ref: session.account.account_ref,
+                    session_created_at: session.client_session.connected_at,
+                    scope: payload.scope,
+                    ...(payload.up_to_event_cursor === undefined
+                        ? {}
+                        : { up_to_event_cursor: payload.up_to_event_cursor }),
+                    ...(options.now === undefined ? {} : { now: options.now }),
+                }),
+            }),
+        });
+        const invalidates = readStateInvalidates();
+        const response = {
+            command_id: execution.command_id,
+            disposition: execution.disposition,
+            invalidates,
+        };
+        if (execution.result !== undefined) {
+            response.result = execution.result;
+        }
+        if (!execution.replayed) {
+            workspaceEvents.publish({
+                event_type: "query.invalidate",
+                payload: {
+                    reason: "bulk_state_change",
+                    message: "Read state changed.",
+                },
+                invalidates,
+            });
+        }
+        return response;
+    });
+}
+//# sourceMappingURL=read-state-routes.js.map

package/dist/server-shell/http/routes/project-api/reference-files-routes.d.ts

@@ -0,0 +1,8 @@
+import type { FastifyInstance } from "fastify";
+import type { WorkspaceEventBus } from "../../workspace-events.js";
+import type { HostProjectApiRouteOptions } from "./types.js";
+export declare function registerReferenceFilesRoutes(app: FastifyInstance, { options, workspaceEvents, }: {
+    options: HostProjectApiRouteOptions;
+    workspaceEvents: WorkspaceEventBus;
+}): void;
+//# sourceMappingURL=reference-files-routes.d.ts.map

package/dist/server-shell/http/routes/project-api/reference-files-routes.js

@@ -0,0 +1,184 @@
+import { GetReferenceFilesRequestSchema, GetReferenceFilesResponseSchema, RefreshReferenceSummariesBodySchema, RefreshReferenceSummariesResponseSchema, UploadReferenceFileBodySchema, UploadReferenceFileResponseSchema, } from "@tutti/shared/schemas/api";
+import { createMainChatMessage, recordReadNotificationEvent, } from "../../../../collaboration-state/index.js";
+import { REFERENCE_DIRECTORY_PATH, uploadReferenceFile, } from "../../../../workspace-ops/index.js";
+import { decideCommandIdempotencyReplay, executeIdempotentCommand, readCommandIdempotencyRecord, } from "../../../command-idempotency/index.js";
+import { HOST_PROJECT_API_BASE_PATH } from "./constants.js";
+import { readReferenceFilesResponse, referenceFileMessageRef, referenceFilesChangedInvalidates, referenceSummaryProcedureInvalidates, referenceUploadMessageBody, toReferenceFileProjection, } from "./reference-files.js";
+import { requireControlPlane, requireHostProjectSession, requireProjectStore, requireWorkspaceRoot, } from "./session-requirements.js";
+import { abortDownloadedStagedUpload, cleanupDownloadedStagedUpload, downloadStagedUpload, } from "./staged-uploads.js";
+export function registerReferenceFilesRoutes(app, { options, workspaceEvents, }) {
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/references/files`, {
+        schema: {
+            querystring: GetReferenceFilesRequestSchema,
+            response: {
+                200: GetReferenceFilesResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        return readReferenceFilesResponse({
+            workspaceRoot: requireWorkspaceRoot(options),
+            ...(options.now === undefined ? {} : { now: options.now }),
+        }, request.query);
+    });
+    app.post(`${HOST_PROJECT_API_BASE_PATH}/references/files`, {
+        schema: {
+            body: UploadReferenceFileBodySchema,
+            response: {
+                200: UploadReferenceFileResponseSchema,
+            },
+        },
+    }, async (request) => {
+        const session = requireHostProjectSession(request, options);
+        const store = requireProjectStore(options);
+        const commandId = request.body.command_id;
+        const command = {
+            command_name: "references.files.upload",
+            target_ref: REFERENCE_DIRECTORY_PATH,
+            payload: request.body.payload,
+        };
+        const replay = decideCommandIdempotencyReplay(readCommandIdempotencyRecord(store.db, commandId), command);
+        let staged;
+        try {
+            staged =
+                replay.kind === "start"
+                    ? await downloadStagedUpload({
+                        routeOptions: options,
+                        expected: request.body.payload,
+                        purpose: "reference_file",
+                    })
+                    : undefined;
+            const invalidates = referenceFilesChangedInvalidates();
+            const execution = executeIdempotentCommand({
+                db: store.db,
+                command_id: commandId,
+                command_name: command.command_name,
+                target_ref: command.target_ref,
+                payload: request.body.payload,
+                ...(options.now === undefined ? {} : { now: options.now }),
+                execute: (tx) => {
+                    if (staged === undefined) {
+                        throw new Error("Staged reference upload was not downloaded");
+                    }
+                    const uploaded = uploadReferenceFile({
+                        workspaceRoot: requireWorkspaceRoot(options),
+                        commandId,
+                        fileName: request.body.payload.file_name,
+                        content: staged.content,
+                        ...(request.body.payload.media_type === undefined
+                            ? {}
+                            : { mediaType: request.body.payload.media_type }),
+                        ...(request.body.payload.note === undefined
+                            ? {}
+                            : { note: request.body.payload.note }),
+                        ...(options.now === undefined ? {} : { now: options.now }),
+                    });
+                    const file = toReferenceFileProjection({
+                        workspaceRoot: requireWorkspaceRoot(options),
+                        entry: uploaded.file,
+                        ...(options.now === undefined ? {} : { now: options.now }),
+                    });
+                    const message = createMainChatMessage(tx, {
+                        body: referenceUploadMessageBody(file),
+                        author: {
+                            kind: "human",
+                            ref: session.account.account_ref,
+                            display_name: session.account.display_name,
+                            avatar: session.account.avatar,
+                        },
+                        refs: {
+                            reference_file: referenceFileMessageRef(file),
+                        },
+                        ...(options.now === undefined ? {} : { now: options.now }),
+                    });
+                    recordReadNotificationEvent(tx, {
+                        scope: "references",
+                        source_kind: "reference_file",
+                        source_ref: file.path,
+                        actor: {
+                            kind: "human",
+                            ref: session.account.account_ref,
+                        },
+                        occurred_at: message.created_at,
+                    });
+                    return {
+                        disposition: { kind: "created" },
+                        result: {
+                            file,
+                            message,
+                            index_path: uploaded.index_path,
+                        },
+                    };
+                },
+            });
+            const response = {
+                command_id: execution.command_id,
+                disposition: execution.disposition,
+                invalidates,
+            };
+            if (execution.result !== undefined) {
+                response.result = execution.result;
+            }
+            if (!execution.replayed && execution.result !== undefined) {
+                if (staged !== undefined) {
+                    await cleanupDownloadedStagedUpload(staged);
+                    staged = undefined;
+                }
+                workspaceEvents.publish({
+                    event_type: "message.created",
+                    payload: { message: execution.result.message },
+                    invalidates,
+                });
+                workspaceEvents.publish({
+                    event_type: "query.invalidate",
+                    payload: {
+                        reason: "viewer_changed",
+                        message: "Reference files changed.",
+                    },
+                    invalidates,
+                });
+                options.controlPlane?.notifyScratchpadSourceChanged();
+                options.controlPlane?.startReferenceSummaryRefresh({
+                    paths: [execution.result.file.path],
+                });
+            }
+            return response;
+        }
+        catch (error) {
+            if (staged !== undefined) {
+                await abortDownloadedStagedUpload(staged);
+            }
+            throw error;
+        }
+    });
+    app.post(`${HOST_PROJECT_API_BASE_PATH}/references/summaries/refresh`, {
+        schema: {
+            body: RefreshReferenceSummariesBodySchema,
+            response: {
+                200: RefreshReferenceSummariesResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        const store = requireProjectStore(options);
+        const execution = executeIdempotentCommand({
+            db: store.db,
+            command_id: request.body.command_id,
+            command_name: "references.summaries.refresh",
+            target_ref: REFERENCE_DIRECTORY_PATH,
+            payload: request.body.payload,
+            ...(options.now === undefined ? {} : { now: options.now }),
+            execute: () => requireControlPlane(options).startReferenceSummaryRefresh(request.body.payload),
+        });
+        const response = {
+            command_id: execution.command_id,
+            disposition: execution.disposition,
+            invalidates: referenceSummaryProcedureInvalidates(),
+        };
+        if (execution.result !== undefined) {
+            response.result = execution.result;
+        }
+        return response;
+    });
+}
+//# sourceMappingURL=reference-files-routes.js.map

package/dist/server-shell/http/routes/project-api/reference-files.d.ts

@@ -0,0 +1,17 @@
+import type { GetReferenceFilesRequest, GetReferenceFilesResponse, MessageCreatedEventPayload, QueryInvalidationHint, ReferenceFileProjection } from "@tutti/shared/schemas/api";
+import { readReferenceSummaryIndex, type ViewerTreeEntry } from "../../../../workspace-ops/index.js";
+export declare function toReferenceFileProjection(options: {
+    workspaceRoot: string;
+    entry: ViewerTreeEntry;
+    summaryIndex?: ReturnType<typeof readReferenceSummaryIndex>;
+    now?: () => Date;
+}): ReferenceFileProjection;
+export declare function readReferenceFilesResponse(options: {
+    workspaceRoot: string;
+    now?: () => Date;
+}, query: GetReferenceFilesRequest): GetReferenceFilesResponse;
+export declare function referenceFilesChangedInvalidates(): QueryInvalidationHint[];
+export declare function referenceSummaryProcedureInvalidates(): QueryInvalidationHint[];
+export declare function referenceUploadMessageBody(file: ReferenceFileProjection): string;
+export declare function referenceFileMessageRef(file: ReferenceFileProjection): NonNullable<NonNullable<MessageCreatedEventPayload["message"]["refs"]>["reference_file"]>;
+//# sourceMappingURL=reference-files.d.ts.map

package/dist/server-shell/http/routes/project-api/reference-files.js

@@ -0,0 +1,212 @@
+import { REFERENCE_DIRECTORY_PATH, REFERENCE_FILES_DIRECTORY_PATH, REFERENCE_IMAGES_DIRECTORY_PATH, REFERENCE_INDEX_PATH, VIEWER_HARD_READ_LIMIT_BYTES, WorkspaceOpsError, readViewerFile, readViewerSnapshot, readViewerTree, readReferenceSummaryIndex, referenceFileCategoryForPath, referenceMediaTypeForPath, referenceSummaryProjectionForEntry, } from "../../../../workspace-ops/index.js";
+import { paginateViewerItems, viewerPageLimit } from "./viewer-projections.js";
+function unreadableReasonForReferenceContent(content) {
+    if (content.kind === "text") {
+        return undefined;
+    }
+    return content.reason;
+}
+function referenceTextReadProjection(workspaceRoot, entry, now) {
+    if (entry.size_bytes !== undefined && entry.size_bytes > VIEWER_HARD_READ_LIMIT_BYTES) {
+        return { can_read: false, blocked_reason: "too_large" };
+    }
+    try {
+        const file = readViewerFile({
+            workspaceRoot,
+            path: entry.path,
+            maxBytes: 1,
+            ...(now === undefined ? {} : { now }),
+        });
+        const reason = unreadableReasonForReferenceContent(file.content);
+        if (reason !== undefined) {
+            return { can_read: false, blocked_reason: reason };
+        }
+        return { can_read: true };
+    }
+    catch {
+        return { can_read: false, blocked_reason: "unknown" };
+    }
+}
+export function toReferenceFileProjection(options) {
+    const category = referenceFileCategoryForPath(options.entry.path) ?? "file";
+    const summaryIndex = options.summaryIndex ?? readReferenceSummaryIndex({ workspaceRoot: options.workspaceRoot });
+    const projection = {
+        path: options.entry.path,
+        name: options.entry.name,
+        category,
+        size_bytes: options.entry.size_bytes ?? 0,
+        text_read: referenceTextReadProjection(options.workspaceRoot, options.entry, options.now),
+        summary: referenceSummaryProjectionForEntry({
+            entry: options.entry,
+            summaries: summaryIndex,
+        }),
+    };
+    if (options.entry.blob_oid !== undefined) {
+        projection.blob_oid = options.entry.blob_oid;
+    }
+    if (options.entry.extension !== undefined) {
+        projection.extension = options.entry.extension;
+    }
+    if (options.entry.language_hint !== undefined) {
+        projection.language_hint = options.entry.language_hint;
+    }
+    const mediaType = referenceMediaTypeForPath(options.entry.path);
+    if (mediaType !== undefined) {
+        projection.media_type = mediaType;
+    }
+    return projection;
+}
+function referenceDirectoryProjection(options) {
+    if (options.directoryStatus === "missing") {
+        return {
+            path: REFERENCE_DIRECTORY_PATH,
+            status: "missing",
+            index_path: REFERENCE_INDEX_PATH,
+            files_path: REFERENCE_FILES_DIRECTORY_PATH,
+            images_path: REFERENCE_IMAGES_DIRECTORY_PATH,
+            index_status: "missing",
+        };
+    }
+    try {
+        const file = readViewerFile({
+            workspaceRoot: options.workspaceRoot,
+            path: REFERENCE_INDEX_PATH,
+            ...(options.now === undefined ? {} : { now: options.now }),
+        });
+        if (file.content.kind === "text") {
+            return {
+                path: REFERENCE_DIRECTORY_PATH,
+                status: "available",
+                index_path: REFERENCE_INDEX_PATH,
+                files_path: REFERENCE_FILES_DIRECTORY_PATH,
+                images_path: REFERENCE_IMAGES_DIRECTORY_PATH,
+                index_status: "available",
+            };
+        }
+        return {
+            path: REFERENCE_DIRECTORY_PATH,
+            status: "available",
+            index_path: REFERENCE_INDEX_PATH,
+            files_path: REFERENCE_FILES_DIRECTORY_PATH,
+            images_path: REFERENCE_IMAGES_DIRECTORY_PATH,
+            index_status: "unreadable",
+            index_unreadable_reason: file.content.reason,
+        };
+    }
+    catch (error) {
+        if (error instanceof WorkspaceOpsError && error.code === "not_found") {
+            return {
+                path: REFERENCE_DIRECTORY_PATH,
+                status: "available",
+                index_path: REFERENCE_INDEX_PATH,
+                files_path: REFERENCE_FILES_DIRECTORY_PATH,
+                images_path: REFERENCE_IMAGES_DIRECTORY_PATH,
+                index_status: "missing",
+            };
+        }
+        throw error;
+    }
+}
+export function readReferenceFilesResponse(options, query) {
+    const workspaceRoot = options.workspaceRoot;
+    const now = options.now;
+    const snapshot = readViewerSnapshot({
+        workspaceRoot,
+        ...(now === undefined ? {} : { now }),
+    });
+    let tree;
+    try {
+        tree = readViewerTree({
+            workspaceRoot,
+            path: REFERENCE_DIRECTORY_PATH,
+            depth: 2,
+            ...(now === undefined ? {} : { now }),
+        });
+    }
+    catch (error) {
+        if (error instanceof WorkspaceOpsError && error.code === "not_found") {
+            return {
+                snapshot,
+                directory: referenceDirectoryProjection({
+                    workspaceRoot,
+                    directoryStatus: "missing",
+                    ...(now === undefined ? {} : { now }),
+                }),
+                items: [],
+                page: {
+                    has_more: false,
+                    limit: viewerPageLimit(query.limit),
+                },
+            };
+        }
+        throw error;
+    }
+    const includeIndex = query.include_index ?? false;
+    const summaryIndex = readReferenceSummaryIndex({ workspaceRoot });
+    const referenceItems = tree.items
+        .filter((entry) => entry.kind === "file")
+        .filter((entry) => includeIndex || entry.path !== REFERENCE_INDEX_PATH)
+        .filter((entry) => entry.path === REFERENCE_INDEX_PATH ||
+        referenceFileCategoryForPath(entry.path) !== undefined)
+        .sort((left, right) => {
+        const leftCategory = referenceFileCategoryForPath(left.path) ?? "file";
+        const rightCategory = referenceFileCategoryForPath(right.path) ?? "file";
+        if (leftCategory !== rightCategory) {
+            return leftCategory.localeCompare(rightCategory, "en", { sensitivity: "base" });
+        }
+        const nameOrder = left.name.localeCompare(right.name, "en", { sensitivity: "base" });
+        return nameOrder === 0
+            ? left.path.localeCompare(right.path, "en", { sensitivity: "base" })
+            : nameOrder;
+    })
+        .map((entry) => toReferenceFileProjection({
+        workspaceRoot,
+        entry,
+        summaryIndex,
+        ...(now === undefined ? {} : { now }),
+    }));
+    const page = paginateViewerItems(referenceItems, query);
+    return {
+        snapshot,
+        directory: referenceDirectoryProjection({
+            workspaceRoot,
+            directoryStatus: "available",
+            ...(now === undefined ? {} : { now }),
+        }),
+        items: page.items,
+        page: page.page,
+    };
+}
+export function referenceFilesChangedInvalidates() {
+    return [
+        { kind: "viewer", path: REFERENCE_DIRECTORY_PATH },
+        { kind: "messages", scope: "main_chat" },
+        { kind: "execution_status" },
+        { kind: "workspace" },
+        { kind: "read_state" },
+        { kind: "bootstrap" },
+    ];
+}
+export function referenceSummaryProcedureInvalidates() {
+    return [{ kind: "execution_status" }, { kind: "bootstrap" }];
+}
+export function referenceUploadMessageBody(file) {
+    return file.category === "image" ? `Uploaded image: ${file.name}` : `Uploaded file: ${file.name}`;
+}
+export function referenceFileMessageRef(file) {
+    const ref = {
+        path: file.path,
+        name: file.name,
+        category: file.category,
+        size_bytes: file.size_bytes,
+        text_read: file.text_read,
+    };
+    if (file.media_type !== undefined) {
+        ref.media_type = file.media_type;
+    }
+    if (file.blob_oid !== undefined) {
+        ref.blob_oid = file.blob_oid;
+    }
+    return ref;
+}
+//# sourceMappingURL=reference-files.js.map

package/dist/server-shell/http/routes/project-api/repo-projection.d.ts

@@ -0,0 +1,3 @@
+import type { HostRepoProjection } from "./types.js";
+export declare function readHostRepoProjection(workspaceRoot: string): HostRepoProjection;
+//# sourceMappingURL=repo-projection.d.ts.map

package/dist/server-shell/http/routes/project-api/repo-projection.js

@@ -0,0 +1,58 @@
+import { spawnSync } from "node:child_process";
+import { HOST_MAINLINE_BRANCH } from "./constants.js";
+const MAINLINE_TIMELINE_LIMIT = 30;
+function runGit(args, cwd) {
+    const result = spawnSync("git", [...args], {
+        cwd,
+        encoding: "utf8",
+        shell: false,
+    });
+    if (result.status !== 0) {
+        return null;
+    }
+    return (result.stdout ?? "").trim();
+}
+function readMainlineTimeline(workspaceRoot) {
+    const output = runGit([
+        "log",
+        HOST_MAINLINE_BRANCH,
+        `--max-count=${MAINLINE_TIMELINE_LIMIT}`,
+        "--date=iso-strict",
+        "--pretty=format:%H%x00%cI",
+    ], workspaceRoot);
+    if (output === null || output.length === 0) {
+        return { entries: [] };
+    }
+    return {
+        entries: output
+            .split("\n")
+            .map((line) => {
+            const [oid, committedAt] = line.split("\0");
+            if (oid === undefined || committedAt === undefined) {
+                return null;
+            }
+            return {
+                oid,
+                committed_at: committedAt,
+            };
+        })
+            .filter((entry) => entry !== null),
+    };
+}
+export function readHostRepoProjection(workspaceRoot) {
+    const oid = runGit(["rev-parse", "--verify", HOST_MAINLINE_BRANCH], workspaceRoot);
+    const status = runGit(["status", "--porcelain"], workspaceRoot);
+    const repo = {
+        mainline_branch: HOST_MAINLINE_BRANCH,
+        mainline_timeline: readMainlineTimeline(workspaceRoot),
+        mainline_clean: status === "",
+    };
+    if (oid !== null && oid.length > 0) {
+        repo.mainline_head = {
+            oid,
+            short_oid: oid.slice(0, 12),
+        };
+    }
+    return repo;
+}
+//# sourceMappingURL=repo-projection.js.map