@xfey/tutti 0.1.0

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

@@ -0,0 +1,658 @@
+import { spawnSync } from "node:child_process";
+import { providerUsageSourceMetadata, readProviderUsageBreakdownForAnchors, readProviderUsageModelSummariesForAnchors, readProviderUsageProjection, readProviderUsageSourceSummariesForAnchors, } from "../../../../provider-usage/index.js";
+import { readProjectTimelineEventItems } from "../../../../project-timeline/index.js";
+import { HOST_MAINLINE_BRANCH } from "./constants.js";
+const TIMELINE_LIMIT = 50;
+const COMMIT_TIMELINE_LIMIT = 30;
+const RUN_RESULT_TIMELINE_LIMIT = 50;
+const TASK_TIMELINE_LIMIT = 50;
+const CLARIFICATION_TIMELINE_LIMIT = 50;
+const RECOVERY_TIMELINE_LIMIT = 30;
+const DURABLE_EVENT_TIMELINE_LIMIT = 50;
+const RUN_USAGE_SOURCES = [
+    "workspace_write_run",
+    "follow_up_run",
+    "pipeline_self_correction",
+];
+const TASK_ADDED_USAGE_SOURCES = ["task_compile"];
+const CONTEXT_SYNC_USAGE_SOURCES = ["context_sync"];
+const REFERENCE_SUMMARY_USAGE_SOURCES = ["reference_summary_refresh"];
+function compareTimelineItemsByTimeDesc(left, right) {
+    const leftTime = Date.parse(left.occurred_at);
+    const rightTime = Date.parse(right.occurred_at);
+    const byTime = Number.isFinite(leftTime) && Number.isFinite(rightTime)
+        ? rightTime - leftTime
+        : right.occurred_at.localeCompare(left.occurred_at);
+    return byTime === 0 ? right.id.localeCompare(left.id) : byTime;
+}
+function attachProviderUsageToItem(db, item, anchors, options = {}) {
+    const tokenUsage = readProviderUsageBreakdownForAnchors(db, anchors, options);
+    if (tokenUsage.event_count <= 0) {
+        return false;
+    }
+    item.token_usage = tokenUsage;
+    item.usage_sources = readProviderUsageSourceSummariesForAnchors(db, anchors, options);
+    item.usage_models = readProviderUsageModelSummariesForAnchors(db, anchors, options);
+    return true;
+}
+function pushConsumedProcedureUsageAnchors(consumed, sources, anchors) {
+    const hasAnchor = anchors.activity_ref !== undefined ||
+        anchors.workflow_ref !== undefined ||
+        anchors.task_id !== undefined;
+    if (!hasAnchor) {
+        return;
+    }
+    for (const source of sources) {
+        if (anchors.activity_ref !== undefined) {
+            consumed.push({ source, activity_ref: anchors.activity_ref });
+        }
+        if (anchors.workflow_ref !== undefined) {
+            consumed.push({ source, workflow_ref: anchors.workflow_ref });
+        }
+        if (anchors.task_id !== undefined) {
+            consumed.push({ source, task_id: anchors.task_id });
+        }
+    }
+}
+function isProcedureUsageConsumed(row, consumed) {
+    return consumed.some((anchor) => {
+        if (anchor.source !== row.source) {
+            return false;
+        }
+        if (anchor.activity_ref !== undefined && anchor.activity_ref !== row.activity_ref) {
+            return false;
+        }
+        if (anchor.workflow_ref !== undefined && anchor.workflow_ref !== row.workflow_ref) {
+            return false;
+        }
+        if (anchor.task_id !== undefined && anchor.task_id !== row.task_id) {
+            return false;
+        }
+        return true;
+    });
+}
+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 parseJsonObject(value) {
+    try {
+        const parsed = JSON.parse(value);
+        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        return {};
+    }
+    return {};
+}
+function parseJsonStringArray(value) {
+    try {
+        const parsed = JSON.parse(value);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        return parsed.filter((item) => typeof item === "string" && item.trim() !== "");
+    }
+    catch {
+        return [];
+    }
+}
+function readCommitTimelineItems(workspaceRoot) {
+    if (workspaceRoot === undefined) {
+        return [];
+    }
+    const output = runGit([
+        "log",
+        HOST_MAINLINE_BRANCH,
+        `--max-count=${COMMIT_TIMELINE_LIMIT}`,
+        "--date=iso-strict",
+        "--pretty=format:%H%x00%cI%x00%s",
+    ], workspaceRoot);
+    if (output === null || output.length === 0) {
+        return [];
+    }
+    return output
+        .split("\n")
+        .map((line) => {
+        const [oid, committedAt, subject] = line.split("\0");
+        if (oid === undefined || committedAt === undefined || subject === undefined) {
+            return null;
+        }
+        return {
+            id: `commit:${oid}`,
+            kind: "commit",
+            occurred_at: committedAt,
+            title: subject.trim() === "" ? "Mainline commit" : subject,
+            commit_oid: oid,
+            commit_short_oid: oid.slice(0, 12),
+            status: "completed",
+        };
+    })
+        .filter((item) => item !== null);
+}
+function runResultStatus(row, result) {
+    if (row.result_kind === "needs_human") {
+        return "needs_human";
+    }
+    if (row.result_kind === "failed" || result.outcome === "failed") {
+        return "failed";
+    }
+    return "completed";
+}
+function runResultTitle(row, status) {
+    const taskTitle = row.task_title ?? "Task";
+    if (status === "needs_human") {
+        return `Needs input: ${taskTitle}`;
+    }
+    if (status === "failed") {
+        return `Run failed: ${taskTitle}`;
+    }
+    return `Run completed: ${taskTitle}`;
+}
+function stringValue(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+function promotionCommit(result) {
+    const promotion = result.promotion;
+    if (typeof promotion !== "object" || promotion === null || Array.isArray(promotion)) {
+        return undefined;
+    }
+    return stringValue(promotion, "commit_oid");
+}
+function runResultMeta(result) {
+    const meta = [];
+    const checks = stringValue(result, "checks");
+    const docs = stringValue(result, "docs");
+    const promotion = result.promotion;
+    if (checks !== undefined) {
+        meta.push(`checks: ${checks}`);
+    }
+    if (docs !== undefined) {
+        meta.push(`docs: ${docs}`);
+    }
+    if (typeof promotion === "object" && promotion !== null && !Array.isArray(promotion)) {
+        const promotionStatus = stringValue(promotion, "status");
+        if (promotionStatus !== undefined) {
+            meta.push(`promotion: ${promotionStatus}`);
+        }
+    }
+    return meta;
+}
+function readTaskTimelineItems(db, consumedProcedureUsageAnchors) {
+    if (db === undefined) {
+        return [];
+    }
+    const rows = db
+        .prepare(`
+        SELECT
+          tasks.id,
+          tasks.title,
+          tasks.summary,
+          tasks.status,
+          tasks.created_from_workflow_ref,
+          tasks.created_at,
+          task_modules.name AS module_name
+        FROM tasks
+        LEFT JOIN task_modules ON task_modules.id = tasks.module_id
+        ORDER BY tasks.created_at DESC, tasks.id DESC
+        LIMIT ${TASK_TIMELINE_LIMIT}
+      `)
+        .all();
+    return rows.map((row) => {
+        const meta = [`status: ${row.status}`];
+        if (row.module_name !== null && row.module_name.trim() !== "") {
+            meta.unshift(`module: ${row.module_name}`);
+        }
+        const item = {
+            id: `task:${row.id}`,
+            kind: "procedure",
+            occurred_at: row.created_at,
+            title: `Task added: ${row.title}`,
+            summary: row.summary,
+            task_id: row.id,
+            task_title: row.title,
+            workflow_ref: row.created_from_workflow_ref,
+            status: "completed",
+            meta,
+        };
+        const anchors = { workflow_ref: row.created_from_workflow_ref };
+        if (attachProviderUsageToItem(db, item, anchors, {
+            sources: TASK_ADDED_USAGE_SOURCES,
+        })) {
+            pushConsumedProcedureUsageAnchors(consumedProcedureUsageAnchors, TASK_ADDED_USAGE_SOURCES, anchors);
+        }
+        return item;
+    });
+}
+function readRunResultTimelineRows(db) {
+    return db
+        .prepare(`
+        SELECT
+          run_results.id,
+          run_results.activity_ref,
+          run_results.task_id,
+          run_results.result_kind,
+          run_results.result_json,
+          run_results.created_at,
+          tasks.title AS task_title
+        FROM run_results
+        LEFT JOIN tasks ON tasks.id = run_results.task_id
+        ORDER BY run_results.created_at DESC, run_results.id DESC
+        LIMIT ${RUN_RESULT_TIMELINE_LIMIT}
+      `)
+        .all();
+}
+function readRunTimelineItems(db, rows) {
+    if (db === undefined) {
+        return [];
+    }
+    return rows.map((row) => {
+        const result = parseJsonObject(row.result_json);
+        const status = runResultStatus(row, result);
+        const commitOid = promotionCommit(result);
+        const item = {
+            id: `run:${row.id}`,
+            kind: "run",
+            occurred_at: row.created_at,
+            title: runResultTitle(row, status),
+            task_id: row.task_id,
+            activity_ref: row.activity_ref,
+            status,
+            meta: runResultMeta(result),
+        };
+        const summary = stringValue(result, "summary");
+        if (summary !== undefined) {
+            item.summary = summary;
+        }
+        if (row.task_title !== null && row.task_title.trim() !== "") {
+            item.task_title = row.task_title;
+        }
+        if (commitOid !== undefined) {
+            item.commit_oid = commitOid;
+            item.commit_short_oid = commitOid.slice(0, 12);
+        }
+        const tokenUsage = readProviderUsageBreakdownForAnchors(db, {
+            activity_ref: row.activity_ref,
+            run_result_id: row.id,
+        }, {
+            sources: RUN_USAGE_SOURCES,
+        });
+        if (tokenUsage.event_count > 0) {
+            item.token_usage = tokenUsage;
+            item.usage_sources = readProviderUsageSourceSummariesForAnchors(db, {
+                activity_ref: row.activity_ref,
+                run_result_id: row.id,
+            }, {
+                sources: RUN_USAGE_SOURCES,
+            });
+            item.usage_models = readProviderUsageModelSummariesForAnchors(db, {
+                activity_ref: row.activity_ref,
+                run_result_id: row.id,
+            }, {
+                sources: RUN_USAGE_SOURCES,
+            });
+        }
+        return item;
+    });
+}
+function checksStatus(value) {
+    if (value === "passed") {
+        return "completed";
+    }
+    if (value === "failed") {
+        return "failed";
+    }
+    if (value === "skipped") {
+        return "skipped";
+    }
+    return undefined;
+}
+function readChecksTimelineItems(rows) {
+    if (rows.length === 0) {
+        return [];
+    }
+    return rows.flatMap((row) => {
+        const result = parseJsonObject(row.result_json);
+        const checks = stringValue(result, "checks");
+        const status = checksStatus(checks);
+        if (checks === undefined || status === undefined) {
+            return [];
+        }
+        const taskTitle = row.task_title ?? "Task";
+        const item = {
+            id: `checks:${row.id}`,
+            kind: "checks",
+            occurred_at: row.created_at,
+            title: `Checks ${checks}: ${taskTitle}`,
+            task_id: row.task_id,
+            activity_ref: row.activity_ref,
+            status,
+            meta: [`run result: ${row.id}`],
+        };
+        if (row.task_title !== null && row.task_title.trim() !== "") {
+            item.task_title = row.task_title;
+        }
+        const summary = stringValue(result, "skip_reason_summary") ??
+            (checks === "skipped" ? stringValue(result, "skip_reason_code") : undefined);
+        if (summary !== undefined) {
+            item.summary = summary;
+        }
+        return [item];
+    });
+}
+function usageBreakdownFromTimelineRow(row) {
+    return {
+        input_tokens: row.input_tokens ?? 0,
+        cached_input_tokens: row.cached_input_tokens ?? 0,
+        output_tokens: row.output_tokens ?? 0,
+        reasoning_output_tokens: row.reasoning_output_tokens ?? 0,
+        total_tokens: row.total_tokens ?? 0,
+        event_count: row.event_count ?? 0,
+    };
+}
+function readProcedureUsageTimelineItems(db, consumedProcedureUsageAnchors) {
+    if (db === undefined) {
+        return [];
+    }
+    const rows = db
+        .prepare(`
+        SELECT
+          source,
+          activity_ref,
+          workflow_ref,
+          task_id,
+          MAX(recorded_at) AS occurred_at,
+          COALESCE(SUM(input_tokens), 0) AS input_tokens,
+          COALESCE(SUM(cached_input_tokens), 0) AS cached_input_tokens,
+          COALESCE(SUM(output_tokens), 0) AS output_tokens,
+          COALESCE(SUM(reasoning_output_tokens), 0) AS reasoning_output_tokens,
+          COALESCE(SUM(total_tokens), 0) AS total_tokens,
+          COUNT(*) AS event_count
+        FROM provider_usage_events
+        WHERE
+          (activity_ref IS NOT NULL OR workflow_ref IS NOT NULL) AND
+          source NOT IN ('workspace_write_run', 'follow_up_run', 'pipeline_self_correction')
+        GROUP BY source, activity_ref, workflow_ref, task_id
+        ORDER BY occurred_at DESC
+        LIMIT 50
+      `)
+        .all();
+    return rows
+        .filter((row) => !isProcedureUsageConsumed(row, consumedProcedureUsageAnchors))
+        .map((row) => {
+        const source = providerUsageSourceMetadata(row.source);
+        const anchor = row.activity_ref ?? row.workflow_ref ?? row.source;
+        const item = {
+            id: `procedure:${anchor}:${row.source}`,
+            kind: "procedure",
+            occurred_at: row.occurred_at,
+            title: source.label,
+            status: "completed",
+            token_usage: usageBreakdownFromTimelineRow(row),
+            usage_sources: [
+                {
+                    source: row.source,
+                    ...source,
+                    ...usageBreakdownFromTimelineRow(row),
+                },
+            ],
+            meta: [`category: ${source.category}`],
+        };
+        if (row.activity_ref !== null) {
+            item.activity_ref = row.activity_ref;
+        }
+        if (row.workflow_ref !== null) {
+            item.workflow_ref = row.workflow_ref;
+        }
+        if (row.task_id !== null) {
+            item.task_id = row.task_id;
+        }
+        item.usage_models = readProviderUsageModelSummariesForAnchors(db, {
+            ...(row.activity_ref === null ? {} : { activity_ref: row.activity_ref }),
+            ...(row.workflow_ref === null ? {} : { workflow_ref: row.workflow_ref }),
+            ...(row.task_id === null ? {} : { task_id: row.task_id }),
+        }, { sources: [row.source] });
+        return item;
+    });
+}
+function clarificationOwnerLabel(row) {
+    if (row.owner_kind === "task") {
+        return row.task_title ?? "Task";
+    }
+    return "Worklist planning";
+}
+function clarificationSummary(row) {
+    return stringValue(parseJsonObject(row.request_payload_json), "summary");
+}
+function clarificationMeta(row, phase) {
+    const meta = [
+        row.owner_kind === "task" ? "owner: task" : "owner: task_compile",
+        `round: ${row.round_index}`,
+    ];
+    if (phase === "answered") {
+        meta.push(`successor: ${row.successor_status}`);
+    }
+    return meta;
+}
+function assignClarificationAnchors(item, row) {
+    if (row.owner_task_id !== null) {
+        item.task_id = row.owner_task_id;
+    }
+    if (row.task_title !== null && row.task_title.trim() !== "") {
+        item.task_title = row.task_title;
+    }
+    if (row.owner_workflow_ref !== null) {
+        item.workflow_ref = row.owner_workflow_ref;
+    }
+    if (row.created_from_activity_ref !== null) {
+        item.activity_ref = row.created_from_activity_ref;
+    }
+}
+function readClarificationTimelineItems(db) {
+    if (db === undefined) {
+        return [];
+    }
+    const rows = db
+        .prepare(`
+        SELECT
+          clarification_rounds.id,
+          clarification_rounds.round_index,
+          clarification_rounds.status,
+          clarification_rounds.request_payload_json,
+          clarification_rounds.submitted_at,
+          clarification_rounds.successor_status,
+          clarification_rounds.created_at,
+          clarification_threads.owner_kind,
+          clarification_threads.owner_workflow_ref,
+          clarification_threads.owner_task_id,
+          clarification_threads.created_from_activity_ref,
+          tasks.title AS task_title
+        FROM clarification_rounds
+        JOIN clarification_threads
+          ON clarification_threads.id = clarification_rounds.clarification_thread_id
+        LEFT JOIN tasks ON tasks.id = clarification_threads.owner_task_id
+        ORDER BY clarification_rounds.created_at DESC, clarification_rounds.id DESC
+        LIMIT ${CLARIFICATION_TIMELINE_LIMIT}
+      `)
+        .all();
+    return rows.flatMap((row) => {
+        const ownerLabel = clarificationOwnerLabel(row);
+        const summary = clarificationSummary(row);
+        const requested = {
+            id: `clarification:${row.id}:requested`,
+            kind: "clarification",
+            occurred_at: row.created_at,
+            title: `Clarification requested: ${ownerLabel}`,
+            status: row.status === "writable" ? "needs_human" : "completed",
+            meta: clarificationMeta(row, "requested"),
+        };
+        if (summary !== undefined) {
+            requested.summary = summary;
+        }
+        assignClarificationAnchors(requested, row);
+        if (row.submitted_at === null) {
+            return [requested];
+        }
+        const answered = {
+            id: `clarification:${row.id}:answered`,
+            kind: "clarification",
+            occurred_at: row.submitted_at,
+            title: `Clarification answered: ${ownerLabel}`,
+            summary: "Human input submitted.",
+            status: "completed",
+            meta: clarificationMeta(row, "answered"),
+        };
+        assignClarificationAnchors(answered, row);
+        return [requested, answered];
+    });
+}
+function readRecoveryTimelineItems(db) {
+    if (db === undefined) {
+        return [];
+    }
+    const rows = db
+        .prepare(`
+        SELECT
+          id,
+          affected_activities_json,
+          summary,
+          created_at
+        FROM recovery_summaries
+        ORDER BY created_at DESC, id DESC
+        LIMIT ${RECOVERY_TIMELINE_LIMIT}
+      `)
+        .all();
+    return rows.map((row) => {
+        const affectedActivities = parseJsonStringArray(row.affected_activities_json);
+        const item = {
+            id: `recovery:${row.id}`,
+            kind: "recovery",
+            occurred_at: row.created_at,
+            title: "Workspace recovery completed",
+            summary: row.summary,
+            status: "completed",
+            meta: [`affected activities: ${affectedActivities.length}`],
+        };
+        if (affectedActivities.length === 1) {
+            item.activity_ref = affectedActivities[0];
+        }
+        return item;
+    });
+}
+function usageSourcesForDurableEventItem(item) {
+    if (item.title === "Docs sync completed" || item.title === "Docs sync failed") {
+        return CONTEXT_SYNC_USAGE_SOURCES;
+    }
+    if (item.title === "Reference summaries refreshed" ||
+        item.title === "Reference summary refresh failed") {
+        return REFERENCE_SUMMARY_USAGE_SOURCES;
+    }
+    return [];
+}
+function attachDurableEventUsage(db, item, consumedProcedureUsageAnchors) {
+    if (db === undefined) {
+        return item;
+    }
+    const sources = usageSourcesForDurableEventItem(item);
+    if (sources.length === 0) {
+        return item;
+    }
+    const anchors = {};
+    if (item.activity_ref !== undefined) {
+        anchors.activity_ref = item.activity_ref;
+    }
+    if (item.workflow_ref !== undefined) {
+        anchors.workflow_ref = item.workflow_ref;
+    }
+    if (item.task_id !== undefined) {
+        anchors.task_id = item.task_id;
+    }
+    if (attachProviderUsageToItem(db, item, anchors, { sources })) {
+        pushConsumedProcedureUsageAnchors(consumedProcedureUsageAnchors, sources, anchors);
+    }
+    return item;
+}
+function shouldDisplayDurableEventItem(item) {
+    if (item.kind === "promotion") {
+        return false;
+    }
+    return item.title !== "Docs sync completed" && item.title !== "Reference summaries refreshed";
+}
+export function readProjectTimelineProjection(input) {
+    const now = input.now ?? (() => new Date());
+    const runRows = input.db === undefined ? [] : readRunResultTimelineRows(input.db);
+    const consumedProcedureUsageAnchors = [];
+    const durableEventItems = input.db === undefined
+        ? []
+        : readProjectTimelineEventItems(input.db, { limit: DURABLE_EVENT_TIMELINE_LIMIT })
+            .filter(shouldDisplayDurableEventItem)
+            .map((item) => attachDurableEventUsage(input.db, item, consumedProcedureUsageAnchors));
+    const items = [
+        ...readTaskTimelineItems(input.db, consumedProcedureUsageAnchors),
+        ...readRunTimelineItems(input.db, runRows),
+        ...readChecksTimelineItems(runRows),
+        ...readProcedureUsageTimelineItems(input.db, consumedProcedureUsageAnchors),
+        ...readClarificationTimelineItems(input.db),
+        ...readRecoveryTimelineItems(input.db),
+        ...durableEventItems,
+        ...readCommitTimelineItems(input.workspaceRoot),
+    ]
+        .filter((item) => item.status !== "skipped")
+        .sort(compareTimelineItemsByTimeDesc);
+    return {
+        generated_at: now().toISOString(),
+        usage_overview: input.db === undefined
+            ? {
+                total_tokens: 0,
+                totals: {
+                    input_tokens: 0,
+                    cached_input_tokens: 0,
+                    output_tokens: 0,
+                    reasoning_output_tokens: 0,
+                    total_tokens: 0,
+                    event_count: 0,
+                },
+                by_source: [],
+                by_model: [],
+                recent_windows: {
+                    today: {
+                        input_tokens: 0,
+                        cached_input_tokens: 0,
+                        output_tokens: 0,
+                        reasoning_output_tokens: 0,
+                        total_tokens: 0,
+                        event_count: 0,
+                    },
+                    last_7_days: {
+                        input_tokens: 0,
+                        cached_input_tokens: 0,
+                        output_tokens: 0,
+                        reasoning_output_tokens: 0,
+                        total_tokens: 0,
+                        event_count: 0,
+                    },
+                    last_30_days: {
+                        input_tokens: 0,
+                        cached_input_tokens: 0,
+                        output_tokens: 0,
+                        reasoning_output_tokens: 0,
+                        total_tokens: 0,
+                        event_count: 0,
+                    },
+                },
+            }
+            : readProviderUsageProjection(input.db, { now }),
+        items: items.slice(0, TIMELINE_LIMIT),
+    };
+}
+//# sourceMappingURL=project-timeline-projection.js.map

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

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+import type { HostProjectApiRouteOptions } from "./types.js";
+export declare function registerProjectTimelineRoutes(app: FastifyInstance, options: HostProjectApiRouteOptions): void;
+//# sourceMappingURL=project-timeline-routes.d.ts.map

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

@@ -0,0 +1,23 @@
+import { ProjectTimelineResponseSchema } from "./schemas.js";
+import { HOST_PROJECT_API_BASE_PATH } from "./constants.js";
+import { requireHostProjectSession } from "./session-requirements.js";
+import { readProjectTimelineProjection } from "./project-timeline-projection.js";
+export function registerProjectTimelineRoutes(app, options) {
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/project-timeline`, {
+        schema: {
+            response: {
+                200: ProjectTimelineResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        return readProjectTimelineProjection({
+            ...(options.store === undefined ? {} : { db: options.store.db }),
+            ...(options.workspaceOps === undefined
+                ? {}
+                : { workspaceRoot: options.workspaceOps.workspaceRoot }),
+            ...(options.now === undefined ? {} : { now: options.now }),
+        });
+    });
+}
+//# sourceMappingURL=project-timeline-routes.js.map

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