@xfey/tutti 0.1.0

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

@@ -0,0 +1,30 @@
+import { ApiErrorResponseSchema, createBrowserFacingOpenApiDocument, } from "@tutti/shared/schemas/api";
+import { HOST_PROJECT_APPROVAL_OPENAPI_ROUTES } from "./openapi-approval-routes.js";
+import { HOST_PROJECT_ARTIFACTS_OPENAPI_ROUTES } from "./openapi-artifacts-routes.js";
+import { HOST_PROJECT_COLLABORATION_OPENAPI_ROUTES } from "./openapi-collaboration-routes.js";
+import { HOST_PROJECT_DIAGNOSTIC_OPENAPI_ROUTES } from "./openapi-diagnostic-routes.js";
+import { HOST_PROJECT_EXECUTION_OPENAPI_ROUTES } from "./openapi-execution-routes.js";
+import { HOST_PROJECT_SKILLS_OPENAPI_ROUTES } from "./openapi-skills-routes.js";
+import { HOST_PROJECT_TIMELINE_OPENAPI_ROUTES } from "./openapi-timeline-routes.js";
+import { HOST_PROJECT_VIEWER_OPENAPI_ROUTES } from "./openapi-viewer-routes.js";
+import { HOST_PROJECT_WORKSPACE_OPENAPI_ROUTES } from "./openapi-workspace-routes.js";
+export const HOST_PROJECT_OPENAPI_ROUTES = [
+    ...HOST_PROJECT_DIAGNOSTIC_OPENAPI_ROUTES,
+    ...HOST_PROJECT_VIEWER_OPENAPI_ROUTES,
+    ...HOST_PROJECT_SKILLS_OPENAPI_ROUTES,
+    ...HOST_PROJECT_ARTIFACTS_OPENAPI_ROUTES,
+    ...HOST_PROJECT_COLLABORATION_OPENAPI_ROUTES,
+    ...HOST_PROJECT_APPROVAL_OPENAPI_ROUTES,
+    ...HOST_PROJECT_EXECUTION_OPENAPI_ROUTES,
+    ...HOST_PROJECT_TIMELINE_OPENAPI_ROUTES,
+    ...HOST_PROJECT_WORKSPACE_OPENAPI_ROUTES,
+];
+export function buildHostProjectOpenApiDocument() {
+    return createBrowserFacingOpenApiDocument({
+        title: "Tutti Host Project API",
+        version: "0.0.0",
+        routes: HOST_PROJECT_OPENAPI_ROUTES,
+        errorSchema: ApiErrorResponseSchema,
+    });
+}
+//# sourceMappingURL=openapi.js.map

package/dist/server-shell/http/routes/project-api/payload-validation.d.ts

@@ -0,0 +1,6 @@
+import type { GetMessagesRequest, SendClarificationRoundMessagePayload, SendMainChatMessagePayload, UpdateProjectDisplayNamePayload } from "@tutti/shared/schemas/api";
+export declare function requireValidMessageWindowRequest(query: GetMessagesRequest): GetMessagesRequest;
+export declare function requireValidSendMainChatPayload(payload: SendMainChatMessagePayload): SendMainChatMessagePayload;
+export declare function requireValidRoundMessagePayload(payload: SendClarificationRoundMessagePayload): SendClarificationRoundMessagePayload;
+export declare function requireValidProjectDisplayNamePayload(payload: UpdateProjectDisplayNamePayload): UpdateProjectDisplayNamePayload;
+//# sourceMappingURL=payload-validation.d.ts.map

package/dist/server-shell/http/routes/project-api/payload-validation.js

@@ -0,0 +1,36 @@
+import { HostProjectBadRequestError, HostProjectValidationError } from "./errors.js";
+export function requireValidMessageWindowRequest(query) {
+    if (query.before !== undefined && query.after !== undefined) {
+        throw new HostProjectBadRequestError("before and after cursors cannot be used together");
+    }
+    return query;
+}
+export function requireValidSendMainChatPayload(payload) {
+    if (payload.body.trim() === "") {
+        throw new HostProjectValidationError("Message body cannot be empty");
+    }
+    if (payload.body.length > 8000) {
+        throw new HostProjectValidationError("Message body cannot exceed 8000 characters");
+    }
+    return payload;
+}
+export function requireValidRoundMessagePayload(payload) {
+    if (payload.body.trim() === "") {
+        throw new HostProjectValidationError("Clarification message body cannot be empty");
+    }
+    if (payload.body.length > 8000) {
+        throw new HostProjectValidationError("Clarification message body cannot exceed 8000 characters");
+    }
+    return payload;
+}
+export function requireValidProjectDisplayNamePayload(payload) {
+    const displayName = payload.display_name.trim();
+    if (displayName.length === 0) {
+        throw new HostProjectValidationError("Project display name cannot be empty");
+    }
+    if (displayName.length > 80) {
+        throw new HostProjectValidationError("Project display name cannot exceed 80 characters");
+    }
+    return { display_name: displayName };
+}
+//# sourceMappingURL=payload-validation.js.map

package/dist/server-shell/http/routes/project-api/project-docs-helpers.d.ts

@@ -0,0 +1,9 @@
+import type { GetProjectDocsResponse, InitializeProjectDocsResult, QueryInvalidationHint } from "@tutti/shared/schemas/api";
+export declare function projectDocsChangedInvalidates(): QueryInvalidationHint[];
+export declare function projectDocsProcedureInvalidates(): QueryInvalidationHint[];
+export declare function readProjectDocsResponse(options: {
+    workspaceRoot: string;
+    now?: () => Date;
+}): GetProjectDocsResponse;
+export declare function initializeProjectDocsCreatedPaths(result: InitializeProjectDocsResult | undefined): string[];
+//# sourceMappingURL=project-docs-helpers.d.ts.map

package/dist/server-shell/http/routes/project-api/project-docs-helpers.js

@@ -0,0 +1,17 @@
+import { readProjectDocsResponse as readProjectDocsWorkspaceResponse } from "../../../../project-docs/context.js";
+export function projectDocsChangedInvalidates() {
+    return [{ kind: "viewer" }, { kind: "workspace" }, { kind: "bootstrap" }];
+}
+export function projectDocsProcedureInvalidates() {
+    return [{ kind: "execution_status" }, { kind: "bootstrap" }];
+}
+export function readProjectDocsResponse(options) {
+    return readProjectDocsWorkspaceResponse({
+        workspaceRoot: options.workspaceRoot,
+        ...(options.now === undefined ? {} : { now: options.now }),
+    });
+}
+export function initializeProjectDocsCreatedPaths(result) {
+    return result !== undefined && "created_paths" in result ? result.created_paths : [];
+}
+//# sourceMappingURL=project-docs-helpers.js.map

package/dist/server-shell/http/routes/project-api/project-docs-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 registerProjectDocsRoutes(app: FastifyInstance, { options, workspaceEvents, }: {
+    options: HostProjectApiRouteOptions;
+    workspaceEvents: WorkspaceEventBus;
+}): void;
+//# sourceMappingURL=project-docs-routes.d.ts.map

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

@@ -0,0 +1,151 @@
+import { ContextSyncBodySchema, ContextSyncResponseSchema, GetProjectDocRequestSchema, GetProjectDocResponseSchema, GetProjectDocsResponseSchema, InitializeProjectDocsBodySchema, InitializeProjectDocsResponseSchema, ProjectDocParamsSchema, } from "@tutti/shared/schemas/api";
+import { projectDocPath, projectDocSummaryFromFile } from "../../../../project-docs/context.js";
+import { WorkspaceOpsError, initializeProjectDocs, readViewerFile, } from "../../../../workspace-ops/index.js";
+import { executeIdempotentCommand } from "../../../command-idempotency/index.js";
+import { HOST_PROJECT_API_BASE_PATH } from "./constants.js";
+import { HostProjectNotFoundError } from "./errors.js";
+import { initializeProjectDocsCreatedPaths, projectDocsChangedInvalidates, projectDocsProcedureInvalidates, readProjectDocsResponse, } from "./project-docs-helpers.js";
+import { requireControlPlane, requireHostProjectSession, requireProjectStore, requireWorkspaceRoot, } from "./session-requirements.js";
+export function registerProjectDocsRoutes(app, { options, workspaceEvents, }) {
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/viewer/project-docs`, {
+        schema: {
+            response: {
+                200: GetProjectDocsResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        return readProjectDocsResponse({
+            workspaceRoot: requireWorkspaceRoot(options),
+            ...(options.now === undefined ? {} : { now: options.now }),
+        });
+    });
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/viewer/project-docs/:doc_key`, {
+        schema: {
+            params: ProjectDocParamsSchema,
+            querystring: GetProjectDocRequestSchema,
+            response: {
+                200: GetProjectDocResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        const workspaceRoot = requireWorkspaceRoot(options);
+        const path = projectDocPath(request.params.doc_key);
+        try {
+            const file = readViewerFile({
+                workspaceRoot,
+                path,
+                ...(request.query.max_bytes === undefined ? {} : { maxBytes: request.query.max_bytes }),
+                ...(options.now === undefined ? {} : { now: options.now }),
+            });
+            return {
+                snapshot: file.snapshot,
+                doc: projectDocSummaryFromFile(request.params.doc_key, file),
+                content: file.content,
+            };
+        }
+        catch (error) {
+            if (error instanceof WorkspaceOpsError && error.code === "not_found") {
+                throw new HostProjectNotFoundError("Project doc was not found");
+            }
+            throw error;
+        }
+    });
+    app.post(`${HOST_PROJECT_API_BASE_PATH}/viewer/project-docs/init`, {
+        schema: {
+            body: InitializeProjectDocsBodySchema,
+            response: {
+                200: InitializeProjectDocsResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        const store = requireProjectStore(options);
+        const execution = executeIdempotentCommand({
+            db: store.db,
+            command_id: request.body.command_id,
+            command_name: "project_docs.init",
+            target_ref: "project_docs:baseline_context",
+            payload: request.body.payload,
+            ...(options.now === undefined ? {} : { now: options.now }),
+            execute: () => {
+                const workspaceRoot = requireWorkspaceRoot(options);
+                const initialized = initializeProjectDocs({
+                    workspaceRoot,
+                    projectName: options.project.display_name,
+                    ...(options.now === undefined ? {} : { now: options.now }),
+                });
+                const docs = readProjectDocsResponse({
+                    workspaceRoot,
+                    ...(options.now === undefined ? {} : { now: options.now }),
+                });
+                return {
+                    disposition: initialized.created_paths.length === 0
+                        ? { kind: "already_initialized" }
+                        : { kind: "created" },
+                    result: {
+                        docs: docs.docs,
+                        created_paths: initialized.created_paths,
+                        ...(initialized.commit_oid === undefined
+                            ? {}
+                            : { commit_oid: initialized.commit_oid }),
+                    },
+                };
+            },
+        });
+        const response = {
+            command_id: execution.command_id,
+            disposition: execution.disposition,
+            invalidates: projectDocsChangedInvalidates(),
+        };
+        if (execution.result !== undefined) {
+            response.result = execution.result;
+        }
+        const createdPaths = initializeProjectDocsCreatedPaths(execution.result);
+        if (!execution.replayed && createdPaths.length !== 0) {
+            workspaceEvents.publish({
+                event_type: "query.invalidate",
+                payload: {
+                    reason: "viewer_changed",
+                    message: "Project docs changed.",
+                },
+                invalidates: projectDocsChangedInvalidates(),
+            });
+            void options.controlPlane
+                ?.refreshProjectBrief({ reason: "project_docs_init" })
+                .catch(() => undefined);
+        }
+        return response;
+    });
+    app.post(`${HOST_PROJECT_API_BASE_PATH}/viewer/project-docs/context-sync`, {
+        schema: {
+            body: ContextSyncBodySchema,
+            response: {
+                200: ContextSyncResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        const store = requireProjectStore(options);
+        const execution = executeIdempotentCommand({
+            db: store.db,
+            command_id: request.body.command_id,
+            command_name: "project_docs.context_sync",
+            target_ref: "project_docs:baseline_context",
+            payload: request.body.payload,
+            ...(options.now === undefined ? {} : { now: options.now }),
+            execute: () => requireControlPlane(options).startContextSyncAnalysis(),
+        });
+        const response = {
+            command_id: execution.command_id,
+            disposition: execution.disposition,
+            invalidates: projectDocsProcedureInvalidates(),
+        };
+        if (execution.result !== undefined) {
+            response.result = execution.result;
+        }
+        return response;
+    });
+}
+//# sourceMappingURL=project-docs-routes.js.map

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

@@ -0,0 +1,8 @@
+import type { ProjectTimelineResponse } from "@tutti/shared/schemas/api";
+import type { SqliteDatabase } from "../../../../store/index.js";
+export declare function readProjectTimelineProjection(input: {
+    db?: SqliteDatabase;
+    workspaceRoot?: string;
+    now?: () => Date;
+}): ProjectTimelineResponse;
+//# sourceMappingURL=project-timeline-projection.d.ts.map