@hunsu/protocol 0.1.0

package/dist/prompt-template.d.ts

@@ -0,0 +1,12 @@
+import { type DomainWorkflowError } from "./errors.ts";
+import { type Result } from "./result.ts";
+export declare const PROMPT_TEMPLATE_ENGINE_V1: "hunsu-template-v1";
+export type PromptTemplate = {
+    engine: typeof PROMPT_TEMPLATE_ENGINE_V1;
+    template: string;
+};
+export type PromptTemplateContext = Record<string, unknown>;
+export declare function promptTemplateFromText(template: string): PromptTemplate;
+export declare function decodePromptTemplate(value: unknown, path: string): Result<PromptTemplate, DomainWorkflowError>;
+export declare function assertValidPromptTemplate(value: unknown, path: string): asserts value is PromptTemplate;
+export declare function renderPromptTemplate(template: PromptTemplate, context: PromptTemplateContext): string;

package/dist/prompt-template.js

@@ -0,0 +1,83 @@
+import { DomainInvariantError, workflowError } from "./errors.js";
+import { ok } from "./result.js";
+export const PROMPT_TEMPLATE_ENGINE_V1 = "hunsu-template-v1";
+export function promptTemplateFromText(template) {
+    return { engine: PROMPT_TEMPLATE_ENGINE_V1, template };
+}
+export function decodePromptTemplate(value, path) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return workflowError(`${path} must be an object`);
+    }
+    const record = value;
+    const allowed = new Set(["engine", "template"]);
+    const unexpected = Object.keys(record).filter(key => !allowed.has(key));
+    if (unexpected.length > 0) {
+        return workflowError(`${path} has unsupported field: ${unexpected[0]}`);
+    }
+    if (!("engine" in record)) {
+        return workflowError(`${path}.engine is required`);
+    }
+    if (!("template" in record)) {
+        return workflowError(`${path}.template is required`);
+    }
+    if (record.engine !== PROMPT_TEMPLATE_ENGINE_V1) {
+        return workflowError(`${path}.engine must be ${PROMPT_TEMPLATE_ENGINE_V1}`);
+    }
+    if (typeof record.template !== "string") {
+        return workflowError(`${path}.template must be a string`);
+    }
+    return ok({ engine: PROMPT_TEMPLATE_ENGINE_V1, template: record.template });
+}
+export function assertValidPromptTemplate(value, path) {
+    const result = decodePromptTemplate(value, path);
+    if (!result.ok) {
+        throw new DomainInvariantError(result.error.message);
+    }
+}
+export function renderPromptTemplate(template, context) {
+    assertValidPromptTemplate(template, "promptTemplate");
+    return template.template.replace(/\{\{\s*([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\[[0-9]+\])*)\s*\}\}/g, (_match, expression) => {
+        const value = resolveTemplateExpression(context, expression);
+        if (value === undefined || value === null) {
+            throw new DomainInvariantError(`Prompt template value is unavailable: ${expression}`);
+        }
+        return formatTemplateValue(value);
+    });
+}
+function resolveTemplateExpression(context, expression) {
+    const tokens = expression.match(/[A-Za-z_$][\w$]*|\[[0-9]+\]/g);
+    if (!tokens || tokens.join("").replace(/\]\[/g, "][") === "") {
+        return undefined;
+    }
+    let current = context;
+    for (const token of tokens) {
+        if (token.startsWith("[")) {
+            const index = Number(token.slice(1, -1));
+            if (!Array.isArray(current)) {
+                return undefined;
+            }
+            current = current[index];
+            continue;
+        }
+        if (typeof current !== "object" || current === null) {
+            return undefined;
+        }
+        current = current[token];
+    }
+    return current;
+}
+function formatTemplateValue(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map(formatTemplateValue).join("\n");
+    }
+    if (typeof value === "object" && value !== null) {
+        return JSON.stringify(value);
+    }
+    return "";
+}

package/dist/protocol-validation.d.ts

@@ -0,0 +1,36 @@
+import { type DomainWorkflowError } from "./errors.ts";
+import type { ExecutorEntity, Harness, HarnessPlannerSnapshot, HarnessSnapshot, ManagerConfig, Member, MemberApprovalConstraint, MemberConfig, MemberExecutionConstraint, MemberPluginBinding, SkillBinding } from "./model.ts";
+import { type PromptTemplate } from "./prompt-template.ts";
+import { type Result } from "./result.ts";
+export declare const DEFAULT_TEAM_PROMPT = "Create a closure-free ExecutionPlan using the available Members.";
+export declare const DEFAULT_MANAGER_PROMPT: string;
+export declare const DEFAULT_MEMBER_EXECUTION: MemberExecutionConstraint;
+export declare const DEFAULT_MEMBER_APPROVAL: MemberApprovalConstraint;
+export declare function validateHarness(value: unknown): Result<HarnessSnapshot, DomainWorkflowError>;
+export declare function validateHarnessPlanner(value: unknown): Result<HarnessPlannerSnapshot, DomainWorkflowError>;
+export declare function validateHarnessEntity(value: unknown, path?: string): Result<Harness, DomainWorkflowError>;
+export declare function validateMemberConfig(value: unknown, path?: string): Result<MemberConfig, DomainWorkflowError>;
+export declare function validateManagerConfig(value: unknown, path?: string): Result<ManagerConfig, DomainWorkflowError>;
+export declare function isExecutableHarness(protocol: HarnessSnapshot): boolean;
+export declare function validateExecutableHarness(protocol: HarnessSnapshot): Result<HarnessSnapshot, DomainWorkflowError>;
+export declare function createDefaultHarness(instructions?: string, skills?: SkillBinding[]): HarnessSnapshot;
+export declare function createDefaultMemberConfig(id: string, prompt?: string, skills?: SkillBinding[], execution?: MemberExecutionConstraint, approval?: MemberApprovalConstraint, plugins?: MemberPluginBinding[]): MemberConfig;
+export declare function createDefaultManagerConfig(id?: string, prompt?: string, skills?: SkillBinding[], plugins?: MemberPluginBinding[]): ManagerConfig;
+export declare function cloneHarness(protocol: HarnessSnapshot): HarnessSnapshot;
+export declare function cloneHarnessPlanner(protocol: HarnessPlannerSnapshot): HarnessPlannerSnapshot;
+export declare function harnessPlannerFromSnapshot(protocol: HarnessSnapshot): HarnessPlannerSnapshot;
+export declare function composeHarnessSnapshot(planner: HarnessPlannerSnapshot, members: MemberConfig[]): HarnessSnapshot;
+export declare function harnessEntityFromSnapshot(protocol: HarnessSnapshot, rootTeamId?: string): Harness;
+export declare function harnessSnapshotForTeam(harness: Harness, teamId?: string): HarnessSnapshot;
+export declare function rootHarnessSnapshot(harness: Harness): HarnessSnapshot;
+export declare function cloneHarnessEntity(harness: Harness): Harness;
+export declare function getHarnessExecutor(harness: Harness, executorId: string): ExecutorEntity | undefined;
+export declare function getHarnessTeam(harness: Harness, executorId: string): Extract<ExecutorEntity, {
+    kind: "team";
+}> | undefined;
+export declare function getHarnessMember(harness: Harness, executorId: string): Member | undefined;
+export declare function memberConfigFromMemberEntity(member: Member): MemberConfig;
+export declare function getHarnessMemberConfig(protocol: HarnessSnapshot, executorId: string): MemberConfig | undefined;
+export declare function updateHarnessMemberConfig(protocol: HarnessSnapshot, executorId: string, update: (member: MemberConfig) => MemberConfig): HarnessSnapshot;
+export declare function updateHarnessTeamPromptTemplate(protocol: HarnessSnapshot, promptTemplate: PromptTemplate): HarnessSnapshot;
+export declare function validateSkillBinding(value: unknown, path: string): void;