@xfey/tutti 0.1.0

package/dist/control-plane/workflows/structured-output-schemas.js

@@ -0,0 +1,289 @@
+const STRING_ARRAY_SCHEMA = {
+    type: "array",
+    items: { type: "string" },
+};
+const CLARIFICATION_REQUEST_PAYLOAD_SCHEMA = {
+    type: "object",
+    required: ["summary", "request", "title"],
+    additionalProperties: false,
+    properties: {
+        summary: { type: "string" },
+        request: { type: "string" },
+        title: { type: "string" },
+    },
+};
+const SCRATCHPAD_SNAPSHOT_SCHEMA = {
+    type: "object",
+    required: [
+        "topic",
+        "background_summary",
+        "current_consensus",
+        "open_questions",
+        "task_changes",
+    ],
+    additionalProperties: false,
+    properties: {
+        topic: { type: "string" },
+        background_summary: { type: "string" },
+        current_consensus: STRING_ARRAY_SCHEMA,
+        open_questions: STRING_ARRAY_SCHEMA,
+        task_changes: STRING_ARRAY_SCHEMA,
+    },
+};
+const SCRATCHPAD_REQUEST_PAYLOAD_SCHEMA = {
+    type: "object",
+    required: ["summary", "request"],
+    additionalProperties: false,
+    properties: {
+        summary: { type: "string" },
+        request: { type: "string" },
+    },
+};
+const PROJECT_CONTEXT_BOOTSTRAP_DOCUMENT_SCHEMA = {
+    type: "object",
+    required: ["doc_key", "content"],
+    additionalProperties: false,
+    properties: {
+        doc_key: {
+            type: "string",
+            enum: ["product", "tech", "structure", "architecture_principles"],
+        },
+        content: { type: "string", minLength: 1 },
+    },
+};
+const TASK_COMPILE_PROPOSAL_SCHEMA = {
+    type: "object",
+    required: ["modules", "tasks"],
+    additionalProperties: false,
+    properties: {
+        modules: {
+            type: "array",
+            items: {
+                type: "object",
+                required: ["temp_key", "name"],
+                additionalProperties: false,
+                properties: {
+                    temp_key: { type: "string", minLength: 1 },
+                    name: { type: "string", minLength: 1 },
+                },
+            },
+        },
+        tasks: {
+            type: "array",
+            items: {
+                type: "object",
+                required: ["module_ref", "title", "goal", "scope"],
+                additionalProperties: false,
+                properties: {
+                    module_ref: {
+                        type: "object",
+                        required: ["kind", "key"],
+                        additionalProperties: false,
+                        properties: {
+                            kind: { type: "string", enum: ["new", "existing"] },
+                            key: { type: "string", minLength: 1 },
+                        },
+                    },
+                    title: { type: "string", minLength: 1 },
+                    goal: { type: "string", minLength: 1 },
+                    scope: STRING_ARRAY_SCHEMA,
+                },
+            },
+        },
+    },
+};
+export const SCRATCHPAD_REFRESH_OUTPUT_SCHEMA = {
+    type: "object",
+    required: ["result"],
+    additionalProperties: false,
+    properties: {
+        result: {
+            anyOf: [
+                {
+                    type: "object",
+                    required: ["decision", "scratchpad_snapshot"],
+                    additionalProperties: false,
+                    properties: {
+                        decision: { type: "string", enum: ["ready"] },
+                        scratchpad_snapshot: SCRATCHPAD_SNAPSHOT_SCHEMA,
+                    },
+                },
+                {
+                    type: "object",
+                    required: ["decision", "request_payload"],
+                    additionalProperties: false,
+                    properties: {
+                        decision: { type: "string", enum: ["needs_human"] },
+                        request_payload: SCRATCHPAD_REQUEST_PAYLOAD_SCHEMA,
+                    },
+                },
+            ],
+        },
+    },
+};
+export const TASK_COMPILE_OUTPUT_SCHEMA = {
+    type: "object",
+    required: ["result"],
+    additionalProperties: false,
+    properties: {
+        result: {
+            anyOf: [
+                {
+                    type: "object",
+                    required: ["proposal"],
+                    additionalProperties: false,
+                    properties: {
+                        proposal: TASK_COMPILE_PROPOSAL_SCHEMA,
+                    },
+                },
+                {
+                    type: "object",
+                    required: ["clarification_request_payload"],
+                    additionalProperties: false,
+                    properties: {
+                        clarification_request_payload: CLARIFICATION_REQUEST_PAYLOAD_SCHEMA,
+                    },
+                },
+            ],
+        },
+    },
+};
+export const PROJECT_CONTEXT_BOOTSTRAP_OUTPUT_SCHEMA = {
+    type: "object",
+    required: ["documents"],
+    additionalProperties: false,
+    properties: {
+        documents: {
+            type: "array",
+            items: PROJECT_CONTEXT_BOOTSTRAP_DOCUMENT_SCHEMA,
+        },
+    },
+};
+const CONTEXT_SYNC_DOCUMENT_UPDATE_SCHEMA = {
+    type: "object",
+    required: ["path", "content"],
+    additionalProperties: false,
+    properties: {
+        path: { type: "string", minLength: 1 },
+        content: { type: "string", minLength: 1 },
+    },
+};
+export const CONTEXT_SYNC_OUTPUT_SCHEMA = {
+    type: "object",
+    required: ["summary", "updates"],
+    additionalProperties: false,
+    properties: {
+        summary: { type: "string" },
+        updates: {
+            type: "array",
+            items: CONTEXT_SYNC_DOCUMENT_UPDATE_SCHEMA,
+        },
+    },
+};
+export const PROJECT_BRIEF_REFRESH_OUTPUT_SCHEMA = {
+    type: "object",
+    required: [
+        "product_summary",
+        "tech_summary",
+        "structure_summary",
+        "principles_summary",
+    ],
+    additionalProperties: false,
+    properties: {
+        product_summary: { type: "string" },
+        tech_summary: { type: "string" },
+        structure_summary: { type: "string" },
+        principles_summary: { type: "string" },
+    },
+};
+export const REFERENCE_FILE_SUMMARY_OUTPUT_SCHEMA = {
+    type: "object",
+    required: ["result"],
+    additionalProperties: false,
+    properties: {
+        result: {
+            anyOf: [
+                {
+                    type: "object",
+                    required: ["summarized"],
+                    additionalProperties: false,
+                    properties: {
+                        summarized: {
+                            type: "object",
+                            required: ["summary"],
+                            additionalProperties: false,
+                            properties: {
+                                summary: { type: "string" },
+                            },
+                        },
+                    },
+                },
+                {
+                    type: "object",
+                    required: ["unavailable"],
+                    additionalProperties: false,
+                    properties: {
+                        unavailable: {
+                            type: "object",
+                            required: ["reason"],
+                            additionalProperties: false,
+                            properties: {
+                                reason: { type: "string" },
+                            },
+                        },
+                    },
+                },
+            ],
+        },
+    },
+};
+export const FOLLOW_UP_CHECK_OUTPUT_SCHEMA = {
+    type: "object",
+    required: ["result"],
+    additionalProperties: false,
+    properties: {
+        result: {
+            anyOf: [
+                {
+                    type: "object",
+                    required: ["resume"],
+                    additionalProperties: false,
+                    properties: {
+                        resume: {
+                            type: "object",
+                            required: ["summary"],
+                            additionalProperties: false,
+                            properties: {
+                                summary: { type: "string" },
+                            },
+                        },
+                    },
+                },
+                {
+                    type: "object",
+                    required: ["needs_more_input"],
+                    additionalProperties: false,
+                    properties: {
+                        needs_more_input: CLARIFICATION_REQUEST_PAYLOAD_SCHEMA,
+                    },
+                },
+                {
+                    type: "object",
+                    required: ["requires_retasking"],
+                    additionalProperties: false,
+                    properties: {
+                        requires_retasking: {
+                            type: "object",
+                            required: ["summary"],
+                            additionalProperties: false,
+                            properties: {
+                                summary: { type: "string" },
+                            },
+                        },
+                    },
+                },
+            ],
+        },
+    },
+};
+//# sourceMappingURL=structured-output-schemas.js.map

package/dist/control-plane/workflows/structured-output-validators.d.ts

@@ -0,0 +1,15 @@
+import type { ContextSyncWorkflowOutput, FollowUpCheckWorkflowOutput, FollowUpCheckStructuredOutput, ProjectBriefRefreshWorkflowOutput, ProjectContextBootstrapWorkflowOutput, ReferenceFileSummaryStructuredOutput, ReferenceFileSummaryWorkflowOutput, ScratchpadRefreshWorkflowOutput, TaskCompileStructuredOutput, TaskCompileWorkflowOutput } from "./types.js";
+export declare function isScratchpadRefreshWorkflowOutput(value: unknown): value is ScratchpadRefreshWorkflowOutput;
+export declare function isScratchpadRefreshStructuredOutput(value: unknown): value is {
+    result: ScratchpadRefreshWorkflowOutput;
+};
+export declare function isTaskCompileWorkflowOutput(value: unknown): value is TaskCompileWorkflowOutput;
+export declare function isTaskCompileStructuredOutput(value: unknown): value is TaskCompileStructuredOutput;
+export declare function isProjectContextBootstrapWorkflowOutput(value: unknown): value is ProjectContextBootstrapWorkflowOutput;
+export declare function isContextSyncWorkflowOutput(value: unknown): value is ContextSyncWorkflowOutput;
+export declare function isProjectBriefRefreshWorkflowOutput(value: unknown): value is ProjectBriefRefreshWorkflowOutput;
+export declare function isReferenceFileSummaryWorkflowOutput(value: unknown): value is ReferenceFileSummaryWorkflowOutput;
+export declare function isReferenceFileSummaryStructuredOutput(value: unknown): value is ReferenceFileSummaryStructuredOutput;
+export declare function isFollowUpCheckStructuredOutput(value: unknown): value is FollowUpCheckStructuredOutput;
+export declare function isFollowUpCheckWorkflowOutput(value: unknown): value is FollowUpCheckWorkflowOutput;
+//# sourceMappingURL=structured-output-validators.d.ts.map

package/dist/control-plane/workflows/structured-output-validators.js

@@ -0,0 +1,295 @@
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function hasExactKeys(value, keys) {
+    const actual = Object.keys(value).sort();
+    return actual.length === keys.length && actual.every((key, index) => key === keys[index]);
+}
+function isOptionalString(value) {
+    return value === undefined || typeof value === "string";
+}
+function nonBlankString(value) {
+    if (value === undefined || value.trim() === "") {
+        return undefined;
+    }
+    return value;
+}
+function isTaskContract(value) {
+    return (isRecord(value) &&
+        hasExactKeys(value, ["goal", "scope"]) &&
+        typeof value.goal === "string" &&
+        isStringArray(value.scope));
+}
+function isClarificationRequestPayload(value) {
+    return (isRecord(value) &&
+        isNonEmptyString(value.summary) &&
+        isNonEmptyString(value.request) &&
+        isOptionalString(value.title));
+}
+function isProjectDocKey(value) {
+    return (value === "product" ||
+        value === "tech" ||
+        value === "structure" ||
+        value === "architecture_principles");
+}
+function isProjectContextBootstrapDocument(value) {
+    return (isRecord(value) &&
+        isProjectDocKey(value.doc_key) &&
+        hasExactKeys(value, ["content", "doc_key"]) &&
+        isNonEmptyString(value.content));
+}
+function isProjectContextBootstrapDocumentArray(value) {
+    return Array.isArray(value) && value.every(isProjectContextBootstrapDocument);
+}
+function isContextSyncDocumentUpdate(value) {
+    return (isRecord(value) &&
+        isNonEmptyString(value.path) &&
+        isNonEmptyString(value.content) &&
+        hasExactKeys(value, ["content", "path"]));
+}
+export function isScratchpadRefreshWorkflowOutput(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    if (value.decision === "ready") {
+        const snapshot = value.scratchpad_snapshot;
+        return (hasExactKeys(value, ["decision", "scratchpad_snapshot"]) &&
+            isRecord(snapshot) &&
+            typeof snapshot.topic === "string" &&
+            typeof snapshot.background_summary === "string" &&
+            isStringArray(snapshot.current_consensus) &&
+            isStringArray(snapshot.open_questions) &&
+            isStringArray(snapshot.task_changes));
+    }
+    return (value.decision === "needs_human" &&
+        hasExactKeys(value, ["decision", "request_payload"]) &&
+        isRecord(value.request_payload) &&
+        isNonEmptyString(value.request_payload.summary) &&
+        isNonEmptyString(value.request_payload.request));
+}
+export function isScratchpadRefreshStructuredOutput(value) {
+    return (isRecord(value) &&
+        hasExactKeys(value, ["result"]) &&
+        isScratchpadRefreshWorkflowOutput(value.result));
+}
+function isTaskCompileProposal(value) {
+    if (!isRecord(value) || !Array.isArray(value.modules) || !Array.isArray(value.tasks)) {
+        return false;
+    }
+    const moduleKeys = new Set();
+    for (const module of value.modules) {
+        if (!isRecord(module) ||
+            !hasExactKeys(module, ["name", "temp_key"]) ||
+            !isNonEmptyString(module.temp_key) ||
+            !isNonEmptyString(module.name)) {
+            return false;
+        }
+        moduleKeys.add(module.temp_key);
+    }
+    for (const task of value.tasks) {
+        if (!isRecord(task)) {
+            return false;
+        }
+        const moduleTempKey = isOptionalString(task.module_temp_key)
+            ? nonBlankString(task.module_temp_key)
+            : undefined;
+        const existingModuleKey = isOptionalString(task.existing_module_key)
+            ? nonBlankString(task.existing_module_key)
+            : undefined;
+        const expectedKeys = moduleTempKey === undefined && existingModuleKey !== undefined
+            ? ["contract", "existing_module_key", "summary", "title"]
+            : moduleTempKey !== undefined && existingModuleKey === undefined
+                ? ["contract", "module_temp_key", "summary", "title"]
+                : [];
+        if (expectedKeys.length === 0 ||
+            !hasExactKeys(task, expectedKeys) ||
+            !isOptionalString(task.module_temp_key) ||
+            !isOptionalString(task.existing_module_key) ||
+            !isNonEmptyString(task.title) ||
+            typeof task.summary !== "string" ||
+            !isTaskContract(task.contract)) {
+            return false;
+        }
+        if ((moduleTempKey === undefined && existingModuleKey === undefined) ||
+            (moduleTempKey !== undefined && existingModuleKey !== undefined)) {
+            return false;
+        }
+        if (moduleTempKey !== undefined && !moduleKeys.has(moduleTempKey)) {
+            return false;
+        }
+    }
+    return true;
+}
+export function isTaskCompileWorkflowOutput(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    if (value.decision === "ready") {
+        return hasExactKeys(value, ["decision", "proposal"]) && isTaskCompileProposal(value.proposal);
+    }
+    return (value.decision === "needs_human" &&
+        hasExactKeys(value, ["clarification_request_payload", "decision"]) &&
+        isClarificationRequestPayload(value.clarification_request_payload));
+}
+function isTaskCompileModuleRef(value, moduleKeys) {
+    if (!isRecord(value) ||
+        !hasExactKeys(value, ["key", "kind"]) ||
+        !isNonEmptyString(value.key)) {
+        return false;
+    }
+    if (value.kind === "new") {
+        return moduleKeys.has(value.key);
+    }
+    return value.kind === "existing";
+}
+function isTaskCompileStructuredProposal(value) {
+    if (!isRecord(value) || !Array.isArray(value.modules) || !Array.isArray(value.tasks)) {
+        return false;
+    }
+    const moduleKeys = new Set();
+    for (const module of value.modules) {
+        if (!isRecord(module) ||
+            !hasExactKeys(module, ["name", "temp_key"]) ||
+            !isNonEmptyString(module.temp_key) ||
+            !isNonEmptyString(module.name)) {
+            return false;
+        }
+        moduleKeys.add(module.temp_key);
+    }
+    for (const task of value.tasks) {
+        if (!isRecord(task) ||
+            !hasExactKeys(task, ["goal", "module_ref", "scope", "title"]) ||
+            !isTaskCompileModuleRef(task.module_ref, moduleKeys) ||
+            !isNonEmptyString(task.title) ||
+            !isNonEmptyString(task.goal) ||
+            !isStringArray(task.scope)) {
+            return false;
+        }
+    }
+    return true;
+}
+function isTaskCompileStructuredResult(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    if (hasExactKeys(value, ["proposal"])) {
+        return isTaskCompileStructuredProposal(value.proposal);
+    }
+    return (hasExactKeys(value, ["clarification_request_payload"]) &&
+        isClarificationRequestPayload(value.clarification_request_payload));
+}
+export function isTaskCompileStructuredOutput(value) {
+    return (isRecord(value) &&
+        hasExactKeys(value, ["result"]) &&
+        isTaskCompileStructuredResult(value.result));
+}
+export function isProjectContextBootstrapWorkflowOutput(value) {
+    if (!isRecord(value) || !hasExactKeys(value, ["documents"])) {
+        return false;
+    }
+    return isProjectContextBootstrapDocumentArray(value.documents);
+}
+export function isContextSyncWorkflowOutput(value) {
+    if (!isRecord(value) || typeof value.summary !== "string") {
+        return false;
+    }
+    return (hasExactKeys(value, ["summary", "updates"]) &&
+        Array.isArray(value.updates) &&
+        value.updates.every(isContextSyncDocumentUpdate));
+}
+export function isProjectBriefRefreshWorkflowOutput(value) {
+    return (isRecord(value) &&
+        hasExactKeys(value, [
+            "principles_summary",
+            "product_summary",
+            "structure_summary",
+            "tech_summary",
+        ]) &&
+        typeof value.product_summary === "string" &&
+        typeof value.tech_summary === "string" &&
+        typeof value.structure_summary === "string" &&
+        typeof value.principles_summary === "string");
+}
+export function isReferenceFileSummaryWorkflowOutput(value) {
+    if (!isRecord(value) ||
+        !hasExactKeys(value, ["decision", "read_paths", "summary", "unavailable_reason"]) ||
+        typeof value.summary !== "string" ||
+        typeof value.unavailable_reason !== "string" ||
+        !isStringArray(value.read_paths)) {
+        return false;
+    }
+    if (value.decision === "summarized") {
+        return value.summary.trim().length > 0 && value.unavailable_reason === "";
+    }
+    return value.decision === "unavailable" && value.unavailable_reason.trim().length > 0;
+}
+export function isReferenceFileSummaryStructuredOutput(value) {
+    if (!isRecord(value) || !isRecord(value.result) || !hasExactKeys(value, ["result"])) {
+        return false;
+    }
+    const branchKeys = Object.keys(value.result);
+    if (branchKeys.length !== 1) {
+        return false;
+    }
+    if ("summarized" in value.result) {
+        const summarized = value.result.summarized;
+        return (isRecord(summarized) &&
+            hasExactKeys(summarized, ["summary"]) &&
+            isNonEmptyString(summarized.summary));
+    }
+    if ("unavailable" in value.result) {
+        const unavailable = value.result.unavailable;
+        return (isRecord(unavailable) &&
+            hasExactKeys(unavailable, ["reason"]) &&
+            isNonEmptyString(unavailable.reason));
+    }
+    return false;
+}
+function isSummaryRecord(value, options) {
+    return (isRecord(value) &&
+        hasExactKeys(value, ["summary"]) &&
+        (options?.requireNonEmpty === true
+            ? isNonEmptyString(value.summary)
+            : typeof value.summary === "string"));
+}
+export function isFollowUpCheckStructuredOutput(value) {
+    if (!isRecord(value) || !isRecord(value.result) || !hasExactKeys(value, ["result"])) {
+        return false;
+    }
+    const branchKeys = Object.keys(value.result);
+    if (branchKeys.length !== 1) {
+        return false;
+    }
+    if ("resume" in value.result) {
+        return isSummaryRecord(value.result.resume);
+    }
+    if ("needs_more_input" in value.result) {
+        return isClarificationRequestPayload(value.result.needs_more_input);
+    }
+    if ("requires_retasking" in value.result) {
+        return isSummaryRecord(value.result.requires_retasking, { requireNonEmpty: true });
+    }
+    return false;
+}
+export function isFollowUpCheckWorkflowOutput(value) {
+    if (!isRecord(value) || typeof value.summary !== "string") {
+        return false;
+    }
+    if (value.decision === "resume") {
+        return hasExactKeys(value, ["decision", "summary"]);
+    }
+    if (value.decision === "needs_more_input") {
+        return (hasExactKeys(value, ["clarification_request_payload", "decision", "summary"]) &&
+            isClarificationRequestPayload(value.clarification_request_payload));
+    }
+    return (value.decision === "requires_retasking" &&
+        hasExactKeys(value, ["decision", "summary"]) &&
+        isNonEmptyString(value.summary));
+}
+//# sourceMappingURL=structured-output-validators.js.map

package/dist/control-plane/workflows/structured-output.d.ts

@@ -0,0 +1,3 @@
+export { CONTEXT_SYNC_OUTPUT_SCHEMA, FOLLOW_UP_CHECK_OUTPUT_SCHEMA, PROJECT_BRIEF_REFRESH_OUTPUT_SCHEMA, PROJECT_CONTEXT_BOOTSTRAP_OUTPUT_SCHEMA, REFERENCE_FILE_SUMMARY_OUTPUT_SCHEMA, SCRATCHPAD_REFRESH_OUTPUT_SCHEMA, TASK_COMPILE_OUTPUT_SCHEMA, } from "./structured-output-schemas.js";
+export { isContextSyncWorkflowOutput, isFollowUpCheckStructuredOutput, isFollowUpCheckWorkflowOutput, isProjectBriefRefreshWorkflowOutput, isProjectContextBootstrapWorkflowOutput, isReferenceFileSummaryStructuredOutput, isReferenceFileSummaryWorkflowOutput, isScratchpadRefreshStructuredOutput, isScratchpadRefreshWorkflowOutput, isTaskCompileStructuredOutput, isTaskCompileWorkflowOutput, } from "./structured-output-validators.js";
+//# sourceMappingURL=structured-output.d.ts.map

package/dist/control-plane/workflows/structured-output.js

@@ -0,0 +1,3 @@
+export { CONTEXT_SYNC_OUTPUT_SCHEMA, FOLLOW_UP_CHECK_OUTPUT_SCHEMA, PROJECT_BRIEF_REFRESH_OUTPUT_SCHEMA, PROJECT_CONTEXT_BOOTSTRAP_OUTPUT_SCHEMA, REFERENCE_FILE_SUMMARY_OUTPUT_SCHEMA, SCRATCHPAD_REFRESH_OUTPUT_SCHEMA, TASK_COMPILE_OUTPUT_SCHEMA, } from "./structured-output-schemas.js";
+export { isContextSyncWorkflowOutput, isFollowUpCheckStructuredOutput, isFollowUpCheckWorkflowOutput, isProjectBriefRefreshWorkflowOutput, isProjectContextBootstrapWorkflowOutput, isReferenceFileSummaryStructuredOutput, isReferenceFileSummaryWorkflowOutput, isScratchpadRefreshStructuredOutput, isScratchpadRefreshWorkflowOutput, isTaskCompileStructuredOutput, isTaskCompileWorkflowOutput, } from "./structured-output-validators.js";
+//# sourceMappingURL=structured-output.js.map