@xfey/tutti 0.1.0

package/dist/artifacts/static-preview.js

@@ -0,0 +1,180 @@
+import { posix } from "node:path";
+import { VIEWER_HARD_READ_LIMIT_BYTES } from "../workspace-ops/constants.js";
+import { WorkspaceOpsError } from "../workspace-ops/errors.js";
+import { entryKind, lsPath, readBlob, requireFileEntry } from "../workspace-ops/viewer-git.js";
+import { requireNormalizedViewerPath } from "../workspace-ops/viewer-paths.js";
+import { readArtifactDeclaration } from "./manifest.js";
+export const ARTIFACT_PREVIEW_CSP = [
+    "default-src 'none'",
+    "script-src 'self' https: 'unsafe-inline' 'unsafe-eval' blob:",
+    "style-src 'self' https: 'unsafe-inline'",
+    "img-src 'self' https: data: blob:",
+    "font-src 'self' https: data:",
+    "media-src 'self' https: data: blob:",
+    "connect-src https: wss:",
+    "worker-src 'self' blob:",
+    "frame-src https:",
+    "frame-ancestors 'self'",
+    "form-action 'none'",
+    "base-uri 'none'",
+    "object-src 'none'",
+].join("; ");
+const MEDIA_TYPE_BY_EXTENSION = new Map([
+    [".html", "text/html; charset=utf-8"],
+    [".htm", "text/html; charset=utf-8"],
+    [".css", "text/css; charset=utf-8"],
+    [".js", "text/javascript; charset=utf-8"],
+    [".mjs", "text/javascript; charset=utf-8"],
+    [".json", "application/json; charset=utf-8"],
+    [".txt", "text/plain; charset=utf-8"],
+    [".png", "image/png"],
+    [".jpg", "image/jpeg"],
+    [".jpeg", "image/jpeg"],
+    [".webp", "image/webp"],
+    [".gif", "image/gif"],
+    [".ico", "image/x-icon"],
+    [".wasm", "application/wasm"],
+    [".woff", "font/woff"],
+    [".woff2", "font/woff2"],
+    [".ttf", "font/ttf"],
+    [".otf", "font/otf"],
+    [".mp4", "video/mp4"],
+    [".webm", "video/webm"],
+    [".mp3", "audio/mpeg"],
+    [".wav", "audio/wav"],
+]);
+const FORBIDDEN_EXTENSIONS = new Set([
+    ".map",
+    ".log",
+    ".sqlite",
+    ".sqlite3",
+    ".db",
+    ".bak",
+]);
+function decodePath(path) {
+    if (path === undefined || path === "") {
+        return "";
+    }
+    try {
+        return decodeURIComponent(path);
+    }
+    catch {
+        return path;
+    }
+}
+function hasHiddenSegment(path) {
+    return path.split("/").some((segment) => segment.startsWith("."));
+}
+function extensionFor(path) {
+    const extension = posix.extname(path).toLowerCase();
+    return extension;
+}
+function mediaTypeFor(path) {
+    const mediaType = MEDIA_TYPE_BY_EXTENSION.get(extensionFor(path));
+    if (mediaType === undefined) {
+        throw new WorkspaceOpsError("validation_failed", "Artifact preview file type is not supported");
+    }
+    return mediaType;
+}
+function previewResourceDirectory(resourcePath) {
+    const normalized = (resourcePath ?? "").split("?")[0]?.replace(/^\/+/u, "") ?? "";
+    if (normalized === "" || normalized.endsWith("/")) {
+        return normalized.replace(/\/+$/u, "");
+    }
+    const directory = posix.dirname(normalized);
+    return directory === "." ? "" : directory;
+}
+function rewriteRootRelativePreviewPath(pathWithoutLeadingSlash, resourcePath) {
+    const targetPath = pathWithoutLeadingSlash.replace(/^\/+/u, "");
+    const relativePath = posix.relative(previewResourceDirectory(resourcePath), targetPath);
+    return relativePath === "" ? "." : relativePath;
+}
+function rewriteHtmlRootRelativeUrls(content, resourcePath) {
+    return content.replace(/\b(href|src|poster|data|action)\s*=\s*(["'])\/(?!\/)([^"']*)\2/giu, (_match, attribute, quote, path) => `${attribute}=${quote}${rewriteRootRelativePreviewPath(path, resourcePath)}${quote}`);
+}
+function rewriteCssRootRelativeUrls(content, resourcePath) {
+    return content
+        .replace(/url\(\s*(["']?)\/(?!\/)([^)"']+)\1\s*\)/giu, (_match, quote, path) => `url(${quote}${rewriteRootRelativePreviewPath(path, resourcePath)}${quote})`)
+        .replace(/(@import\s+)(["'])\/(?!\/)([^"']+)\2/giu, (_match, prefix, quote, path) => `${prefix}${quote}${rewriteRootRelativePreviewPath(path, resourcePath)}${quote}`);
+}
+export function rewriteArtifactPreviewResourceUrls(options) {
+    const mediaType = options.mediaType?.toLowerCase() ?? "";
+    if (mediaType.includes("text/html")) {
+        return Buffer.from(rewriteHtmlRootRelativeUrls(options.content.toString("utf8"), options.resourcePath), "utf8");
+    }
+    if (mediaType.includes("text/css")) {
+        return Buffer.from(rewriteCssRootRelativeUrls(options.content.toString("utf8"), options.resourcePath), "utf8");
+    }
+    return options.content;
+}
+function requireSafeArtifactAssetPath(path) {
+    let normalized;
+    try {
+        normalized = requireNormalizedViewerPath(path);
+    }
+    catch (error) {
+        if (error instanceof WorkspaceOpsError) {
+            throw new WorkspaceOpsError("forbidden", "Artifact preview path is not allowed");
+        }
+        throw error;
+    }
+    if (hasHiddenSegment(normalized)) {
+        throw new WorkspaceOpsError("forbidden", "Artifact preview path is not allowed");
+    }
+    if (FORBIDDEN_EXTENSIONS.has(extensionFor(normalized))) {
+        throw new WorkspaceOpsError("forbidden", "Artifact preview file type is not allowed");
+    }
+    return normalized;
+}
+function requireDeclaredStaticArtifact(declaration) {
+    if (declaration.status === "not_declared") {
+        throw new WorkspaceOpsError("not_found", "Artifact is not declared");
+    }
+    if (declaration.status === "invalid") {
+        throw new WorkspaceOpsError("validation_failed", "Artifact manifest is invalid");
+    }
+    if (declaration.runtime.kind !== "static") {
+        throw new WorkspaceOpsError("validation_failed", "Artifact is not static");
+    }
+    return declaration;
+}
+export function readArtifactStaticPreview(options) {
+    const declaration = requireDeclaredStaticArtifact(readArtifactDeclaration({
+        workspaceRoot: options.workspaceRoot,
+        ...(options.now === undefined ? {} : { now: options.now }),
+    }));
+    const runtime = declaration.runtime;
+    if (runtime.kind !== "static") {
+        throw new WorkspaceOpsError("validation_failed", "Artifact is not static");
+    }
+    const requestedPath = requireSafeArtifactAssetPath(decodePath(options.path));
+    const relativePath = requestedPath === "" ? runtime.entry_path : requestedPath;
+    const repoPath = runtime.root_path === "" ? relativePath : posix.join(runtime.root_path, relativePath);
+    const entry = lsPath(options.workspaceRoot, repoPath);
+    if (entry === null) {
+        throw new WorkspaceOpsError("not_found", "Artifact preview file was not found");
+    }
+    if (entryKind(entry) !== "file") {
+        throw new WorkspaceOpsError("validation_failed", "Artifact preview path is not a file");
+    }
+    if (entry.size === undefined || !Number.isSafeInteger(entry.size)) {
+        throw new WorkspaceOpsError("git_failed", "Artifact preview file size is unavailable");
+    }
+    if (entry.size > VIEWER_HARD_READ_LIMIT_BYTES) {
+        throw new WorkspaceOpsError("validation_failed", "Artifact preview file is too large");
+    }
+    const fileEntry = requireFileEntry({
+        workspaceRoot: options.workspaceRoot,
+        path: repoPath,
+    });
+    const mediaType = mediaTypeFor(repoPath);
+    return {
+        media_type: mediaType,
+        content: rewriteArtifactPreviewResourceUrls({
+            mediaType,
+            resourcePath: relativePath,
+            content: readBlob(options.workspaceRoot, fileEntry.oid, fileEntry.size),
+        }),
+    };
+}
+//# sourceMappingURL=static-preview.js.map

package/dist/chat-assistant/index.d.ts

@@ -0,0 +1,66 @@
+import type { ProjectId } from "@tutti/shared/ids";
+import type { MessageProjection } from "@tutti/shared/schemas/api";
+import type { HostProjectStore } from "../store/index.js";
+import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
+export declare const CHAT_ASSISTANT_OUTPUT_SCHEMA: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["answer"];
+    readonly properties: {
+        readonly answer: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 6000;
+        };
+    };
+};
+export type ChatAssistantOutput = {
+    answer: string;
+};
+export type ChatAssistantPromptInput = {
+    prompt: string;
+};
+export type ReadOnlyChatAssistantModel = {
+    answer: (input: ChatAssistantPromptInput) => Promise<ChatAssistantOutput>;
+};
+export type ReadOnlyChatAssistantTriggerInput = {
+    message: MessageProjection;
+};
+export type ReadOnlyChatAssistantEnqueueResult = {
+    triggered: boolean;
+};
+export type ReadOnlyChatAssistantHandle = {
+    enqueue: (input: ReadOnlyChatAssistantTriggerInput) => ReadOnlyChatAssistantEnqueueResult;
+    waitForIdle: () => Promise<void>;
+};
+export type ReadOnlyChatAssistantOptions = {
+    project: {
+        project_id: ProjectId;
+        display_name: string;
+    };
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    workspaceRoot: string;
+    model: ReadOnlyChatAssistantModel;
+    promptsRoot?: string;
+    onScratchpadSourceChanged?: () => void;
+    now?: () => Date;
+};
+export declare function isChatAssistantOutput(value: unknown): value is ChatAssistantOutput;
+export declare function containsTuttiMention(value: string): boolean;
+export declare class ReadOnlyChatAssistant implements ReadOnlyChatAssistantHandle {
+    private readonly options;
+    private readonly inFlight;
+    constructor(options: ReadOnlyChatAssistantOptions);
+    enqueue(input: ReadOnlyChatAssistantTriggerInput): ReadOnlyChatAssistantEnqueueResult;
+    waitForIdle(): Promise<void>;
+    private buildMainChatContext;
+    private buildClarificationRoundContext;
+    private buildContext;
+    private renderPrompt;
+    private appendMainChatAssistantMessage;
+    private appendClarificationRoundAssistantMessage;
+    private appendAssistantMessageForTrigger;
+    private respond;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/chat-assistant/index.js

@@ -0,0 +1,268 @@
+import { createClarificationRoundAgentMessage, createMainChatAgentMessage, readClarificationRoundMessagesWindow, readClarificationRoundProjection, readMainChatMessageWindow, readMainChatMessagesBeforeCursor, readMessageProjectionById, } from "../collaboration-state/index.js";
+import { renderPromptTemplate } from "../prompt-templates/index.js";
+const CHAT_ASSISTANT_CONTEXT_MESSAGE_LIMIT = 3;
+const CHAT_ASSISTANT_ROUND_MESSAGE_LIMIT = 50;
+const CHAT_ASSISTANT_ROUND_MESSAGE_MAX_CHARS = 2_000;
+const CHAT_ASSISTANT_ROUND_TOTAL_MAX_CHARS = 15_000;
+const CHAT_ASSISTANT_ROUND_MAIN_CHAT_CONTEXT_LIMIT = 5;
+const CHAT_ASSISTANT_MAX_ANSWER_CHARS = 6000;
+export const CHAT_ASSISTANT_OUTPUT_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    required: ["answer"],
+    properties: {
+        answer: {
+            type: "string",
+            minLength: 1,
+            maxLength: CHAT_ASSISTANT_MAX_ANSWER_CHARS,
+        },
+    },
+};
+export function isChatAssistantOutput(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        typeof value.answer === "string" &&
+        value.answer.trim().length > 0);
+}
+export function containsTuttiMention(value) {
+    return /(^|[^\p{L}\p{N}_])@tutti(?=$|[^\p{L}\p{N}_-])/iu.test(value);
+}
+function mainChatMessageInvalidates() {
+    return [
+        { kind: "messages", scope: "main_chat" },
+        { kind: "read_state" },
+        { kind: "bootstrap" },
+    ];
+}
+function normalizeAnswer(answer) {
+    const trimmed = answer.trim();
+    if (trimmed.length <= CHAT_ASSISTANT_MAX_ANSWER_CHARS) {
+        return trimmed;
+    }
+    return `${trimmed.slice(0, CHAT_ASSISTANT_MAX_ANSWER_CHARS - 3)}...`;
+}
+function assistantFailureMessage() {
+    return "Tutti could not complete this read-only answer. Try again later, or add more context in chat.";
+}
+function messageToContext(message) {
+    const authorDisplayName = message.author.display_name?.trim();
+    return {
+        ...(authorDisplayName === undefined || authorDisplayName === ""
+            ? {}
+            : { author_display_name: authorDisplayName }),
+        text: message.body,
+    };
+}
+function messageRole(message) {
+    if (message.author.kind === "agent") {
+        return "tutti";
+    }
+    if (message.author.kind === "human") {
+        return "human";
+    }
+    return "system";
+}
+function truncateRoundMessageText(text, remainingChars) {
+    if (remainingChars <= 0) {
+        return undefined;
+    }
+    const trimmed = text.trim();
+    if (trimmed.length <= Math.min(CHAT_ASSISTANT_ROUND_MESSAGE_MAX_CHARS, remainingChars)) {
+        return trimmed;
+    }
+    const maxChars = Math.max(0, Math.min(CHAT_ASSISTANT_ROUND_MESSAGE_MAX_CHARS, remainingChars) - 3);
+    return `${trimmed.slice(0, maxChars)}...`;
+}
+function roundMessagesToContext(messages) {
+    const result = [];
+    let remainingChars = CHAT_ASSISTANT_ROUND_TOTAL_MAX_CHARS;
+    for (const message of messages) {
+        const text = truncateRoundMessageText(message.body, remainingChars);
+        if (text === undefined) {
+            break;
+        }
+        remainingChars -= text.length;
+        const authorDisplayName = message.author.display_name?.trim();
+        result.push({
+            role: messageRole(message),
+            kind: message.message_kind,
+            ...(authorDisplayName === undefined || authorDisplayName === ""
+                ? {}
+                : { author_display_name: authorDisplayName }),
+            text,
+        });
+    }
+    return result;
+}
+export class ReadOnlyChatAssistant {
+    options;
+    inFlight = new Set();
+    constructor(options) {
+        this.options = options;
+    }
+    enqueue(input) {
+        if (!containsTuttiMention(input.message.body)) {
+            return { triggered: false };
+        }
+        const task = this.respond(input.message).catch(() => undefined);
+        this.inFlight.add(task);
+        void task.finally(() => {
+            this.inFlight.delete(task);
+        });
+        return { triggered: true };
+    }
+    async waitForIdle() {
+        await Promise.all([...this.inFlight]);
+    }
+    buildMainChatContext(triggerMessage) {
+        const authorDisplayName = triggerMessage.author.display_name?.trim();
+        return {
+            mode: "main_chat",
+            project: {
+                display_name: this.options.project.display_name,
+            },
+            trigger: {
+                ...(authorDisplayName === undefined || authorDisplayName === ""
+                    ? {}
+                    : { author_display_name: authorDisplayName }),
+                text: triggerMessage.body,
+            },
+            recent_messages: readMainChatMessageWindow(this.options.store.db, {
+                limit: CHAT_ASSISTANT_CONTEXT_MESSAGE_LIMIT,
+            }).items.map(messageToContext),
+        };
+    }
+    buildClarificationRoundContext(triggerMessage, roundId) {
+        const round = readClarificationRoundProjection(this.options.store.db, roundId);
+        if (round === null) {
+            return null;
+        }
+        const messages = readClarificationRoundMessagesWindow(this.options.store.db, roundId, {
+            anchor: "start",
+            limit: CHAT_ASSISTANT_ROUND_MESSAGE_LIMIT,
+        });
+        const cardMessage = readMessageProjectionById(this.options.store.db, round.card_message_id);
+        const recentMainChatBeforeRound = cardMessage === null
+            ? []
+            : readMainChatMessagesBeforeCursor(this.options.store.db, {
+                before_created_at: cardMessage.created_at,
+                before_id: cardMessage.id,
+                limit: CHAT_ASSISTANT_ROUND_MAIN_CHAT_CONTEXT_LIMIT,
+            }).map(messageToContext);
+        const authorDisplayName = triggerMessage.author.display_name?.trim();
+        return {
+            mode: "clarification_round",
+            project: {
+                display_name: this.options.project.display_name,
+            },
+            trigger: {
+                ...(authorDisplayName === undefined || authorDisplayName === ""
+                    ? {}
+                    : { author_display_name: authorDisplayName }),
+                text: triggerMessage.body,
+            },
+            round_request: {
+                ...(round.request_payload.title === undefined
+                    ? {}
+                    : { title: round.request_payload.title }),
+                summary: round.request_payload.summary,
+                request: round.request_payload.request,
+            },
+            round_messages: roundMessagesToContext(messages?.items ?? []),
+            recent_main_chat_before_round: recentMainChatBeforeRound,
+        };
+    }
+    buildContext(triggerMessage) {
+        if (triggerMessage.scope.kind === "clarification_round") {
+            return this.buildClarificationRoundContext(triggerMessage, triggerMessage.scope.clarification_round_ref);
+        }
+        return this.buildMainChatContext(triggerMessage);
+    }
+    renderPrompt(triggerMessage) {
+        const context = this.buildContext(triggerMessage);
+        if (context === null) {
+            return null;
+        }
+        return renderPromptTemplate({
+            templateKey: "chat.assistant",
+            ...(this.options.promptsRoot === undefined ? {} : { promptsRoot: this.options.promptsRoot }),
+            variables: {
+                assistant_context_json: context,
+            },
+        });
+    }
+    appendMainChatAssistantMessage(body, refs) {
+        const message = createMainChatAgentMessage(this.options.store.db, {
+            body,
+            ...(refs === undefined ? {} : { refs }),
+            ...(this.options.now === undefined ? {} : { now: this.options.now }),
+        });
+        this.options.events.publish({
+            event_type: "message.created",
+            payload: {
+                message,
+            },
+            invalidates: mainChatMessageInvalidates(),
+        });
+        if (refs?.scratchpad_source !== "exclude") {
+            this.options.onScratchpadSourceChanged?.();
+        }
+    }
+    appendClarificationRoundAssistantMessage(input) {
+        const round = readClarificationRoundProjection(this.options.store.db, input.roundId);
+        const message = createClarificationRoundAgentMessage(this.options.store.db, {
+            round_id: input.roundId,
+            body: input.body,
+            ...(input.refs === undefined ? {} : { refs: input.refs }),
+            ...(this.options.now === undefined ? {} : { now: this.options.now }),
+        });
+        const invalidates = [
+            {
+                kind: "clarification",
+                round_id: input.roundId,
+                ...(round === null ? {} : { thread_id: round.thread_id }),
+            },
+            { kind: "messages", scope: "clarification_round", round_id: input.roundId },
+            { kind: "messages", scope: "main_chat" },
+            { kind: "read_state" },
+            { kind: "bootstrap" },
+        ];
+        this.options.events.publish({
+            event_type: "message.created",
+            payload: {
+                message,
+            },
+            invalidates,
+        });
+    }
+    appendAssistantMessageForTrigger(triggerMessage, body, refs) {
+        if (triggerMessage.scope.kind === "clarification_round") {
+            this.appendClarificationRoundAssistantMessage({
+                roundId: triggerMessage.scope.clarification_round_ref,
+                body,
+                ...(refs === undefined ? {} : { refs }),
+            });
+            return;
+        }
+        this.appendMainChatAssistantMessage(body, refs);
+    }
+    async respond(triggerMessage) {
+        try {
+            const prompt = this.renderPrompt(triggerMessage);
+            if (prompt === null) {
+                return;
+            }
+            const output = await this.options.model.answer({
+                prompt,
+            });
+            this.appendAssistantMessageForTrigger(triggerMessage, normalizeAnswer(output.answer));
+        }
+        catch {
+            this.appendAssistantMessageForTrigger(triggerMessage, assistantFailureMessage(), {
+                scratchpad_source: "exclude",
+            });
+        }
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/checks/index.d.ts

@@ -0,0 +1,47 @@
+import type { CheckSkipReasonCode } from "@tutti/shared/schemas/api";
+export type CheckCommand = {
+    id: string;
+    label: string;
+    command: string;
+    args: string[];
+    required: boolean;
+};
+export type CheckPlan = {
+    commands: CheckCommand[];
+    skip_reason_code?: CheckSkipReasonCode;
+    skip_reason_summary?: string;
+};
+export type CheckCommandResult = {
+    id: string;
+    label: string;
+    command: string;
+    args: string[];
+    status: "passed" | "failed" | "timed_out";
+    exit_code?: number;
+    duration_ms: number;
+    stdout: string;
+    stderr: string;
+};
+export type ChecksExecutionResult = {
+    status: "passed";
+    commands: CheckCommandResult[];
+} | {
+    status: "failed";
+    commands: CheckCommandResult[];
+} | {
+    status: "skipped";
+    commands: CheckCommandResult[];
+    skip_reason_code: CheckSkipReasonCode;
+    skip_reason_summary: string;
+};
+export type CreateNodeNpmCheckPlanOptions = {
+    workspaceRoot: string;
+};
+export type ExecuteCheckPlanOptions = {
+    workspaceRoot: string;
+    plan: CheckPlan;
+    timeoutMs?: number;
+};
+export declare function createNodeNpmCheckPlan(options: CreateNodeNpmCheckPlanOptions): CheckPlan;
+export declare function executeCheckPlan(options: ExecuteCheckPlanOptions): Promise<ChecksExecutionResult>;
+//# sourceMappingURL=index.d.ts.map