@useorgx/openclaw-plugin 0.4.8 → 0.4.9

package/dist/http/helpers/kickoff-context.js

@@ -0,0 +1,154 @@
+function normalizeKickoffContextResponse(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    if (typeof record.context_hash === "string" && record.context_hash.trim().length > 0) {
+        return record;
+    }
+    if (record.ok === true && record.data && typeof record.data === "object") {
+        const data = record.data;
+        if (typeof data.context_hash === "string" && data.context_hash.trim().length > 0) {
+            return data;
+        }
+    }
+    return null;
+}
+export async function fetchKickoffContextSafe(client, payload) {
+    try {
+        const anyClient = client;
+        if (typeof anyClient.getKickoffContext === "function") {
+            const resp = await anyClient.getKickoffContext(payload);
+            return normalizeKickoffContextResponse(resp);
+        }
+        if (typeof anyClient.rawRequest === "function") {
+            const resp = await anyClient.rawRequest("POST", "/api/client/kickoff-context", payload ?? {});
+            return normalizeKickoffContextResponse(resp);
+        }
+    }
+    catch {
+        // best effort: fall back to local kickoff message
+    }
+    return null;
+}
+function normalizeKickoffLines(input) {
+    if (!Array.isArray(input))
+        return [];
+    return input
+        .map((line) => (typeof line === "string" ? line.trim() : ""))
+        .filter((line) => line.length > 0);
+}
+export function renderKickoffMessage(input) {
+    const base = input.baseMessage.trim();
+    const kickoff = input.kickoff;
+    if (!kickoff)
+        return { message: base, contextHash: null };
+    const title = (kickoff.task?.title ??
+        kickoff.workstream?.title ??
+        kickoff.initiative?.title ??
+        "").trim();
+    const overview = (kickoff.overview ?? "").trim();
+    const acceptance = normalizeKickoffLines(kickoff.acceptance_criteria ?? null);
+    const constraints = normalizeKickoffLines(kickoff.constraints ?? null);
+    const risks = normalizeKickoffLines(kickoff.risks ?? null);
+    const reporting = normalizeKickoffLines(kickoff.reporting_expectations ?? null);
+    const decisions = Array.isArray(kickoff.decisions) ? kickoff.decisions : [];
+    const artifacts = Array.isArray(kickoff.artifacts) ? kickoff.artifacts : [];
+    const allow = normalizeKickoffLines(kickoff.tool_scope?.allow ?? null);
+    const deny = normalizeKickoffLines(kickoff.tool_scope?.deny ?? null);
+    const toolNotes = (kickoff.tool_scope?.notes ?? "").trim();
+    const contextHash = kickoff.context_hash?.trim() || null;
+    const schemaVersion = (kickoff.schema_version ?? "").trim();
+    const lines = [];
+    lines.push("# Kickoff");
+    lines.push("");
+    if (title) {
+        lines.push(`## Target`);
+        lines.push(`- ${title}`);
+        lines.push("");
+    }
+    if (overview) {
+        lines.push("## Overview");
+        lines.push(overview);
+        lines.push("");
+    }
+    else if (base) {
+        lines.push("## Objective");
+        lines.push(base);
+        lines.push("");
+    }
+    if (acceptance.length > 0) {
+        lines.push("## Acceptance Criteria");
+        for (const item of acceptance)
+            lines.push(`- ${item}`);
+        lines.push("");
+    }
+    if (constraints.length > 0) {
+        lines.push("## Constraints");
+        for (const item of constraints)
+            lines.push(`- ${item}`);
+        lines.push("");
+    }
+    if (risks.length > 0) {
+        lines.push("## Risks");
+        for (const item of risks)
+            lines.push(`- ${item}`);
+        lines.push("");
+    }
+    if (decisions.length > 0 || artifacts.length > 0) {
+        lines.push("## References");
+        for (const item of decisions) {
+            const decisionTitle = typeof item?.title === "string"
+                ? String(item.title).trim()
+                : "";
+            const id = typeof item?.id === "string" ? String(item.id).trim() : "";
+            const label = decisionTitle || id || "decision";
+            lines.push(`- Decision: ${label}`);
+        }
+        for (const item of artifacts) {
+            const artifactTitle = typeof item?.title === "string"
+                ? String(item.title).trim()
+                : "";
+            const id = typeof item?.id === "string" ? String(item.id).trim() : "";
+            const label = artifactTitle || id || "artifact";
+            lines.push(`- Artifact: ${label}`);
+        }
+        lines.push("");
+    }
+    lines.push("## Operating Mode");
+    if (input.domain)
+        lines.push(`- Domain: ${input.domain}`);
+    if (input.requiredSkills.length > 0) {
+        lines.push(`- Skills: ${input.requiredSkills.join(", ")}`);
+    }
+    lines.push("- Communicate early when blocked. Provide options, tradeoffs, and a recommendation.");
+    lines.push("- Verify before claiming done. Prefer proof (commands/tests) over confidence.");
+    lines.push("");
+    if (allow.length > 0 || deny.length > 0 || toolNotes) {
+        lines.push("## Tool Scope");
+        if (allow.length > 0)
+            lines.push(`- Allow: ${allow.join(", ")}`);
+        if (deny.length > 0)
+            lines.push(`- Deny: ${deny.join(", ")}`);
+        if (toolNotes)
+            lines.push(`- Notes: ${toolNotes}`);
+        lines.push("");
+    }
+    if (reporting.length > 0) {
+        lines.push("## Reporting");
+        for (const item of reporting)
+            lines.push(`- ${item}`);
+        lines.push("");
+    }
+    if (contextHash || schemaVersion) {
+        lines.push("## Provenance");
+        if (schemaVersion)
+            lines.push(`- kickoff_schema: ${schemaVersion}`);
+        if (contextHash)
+            lines.push(`- kickoff_context_hash: ${contextHash}`);
+        lines.push("");
+    }
+    return {
+        message: lines.join("\n").trimEnd(),
+        contextHash,
+    };
+}

package/dist/http/helpers/mission-control.d.ts

@@ -0,0 +1,94 @@
+import type { OrgXClient } from "../../api.js";
+import type { Entity } from "../../types.js";
+export type MissionControlNodeType = "initiative" | "workstream" | "milestone" | "task";
+export interface MissionControlAssignedAgent {
+    id: string;
+    name: string;
+    domain: string | null;
+}
+export interface MissionControlNode {
+    id: string;
+    type: MissionControlNodeType;
+    title: string;
+    status: string;
+    parentId: string | null;
+    initiativeId: string | null;
+    workstreamId: string | null;
+    milestoneId: string | null;
+    priorityNum: number;
+    priorityLabel: string | null;
+    dependencyIds: string[];
+    dueDate: string | null;
+    etaEndAt: string | null;
+    expectedDurationHours: number;
+    expectedBudgetUsd: number;
+    assignedAgents: MissionControlAssignedAgent[];
+    updatedAt: string | null;
+}
+export interface MissionControlEdge {
+    from: string;
+    to: string;
+    kind: "depends_on";
+}
+export declare const ORGX_SKILL_BY_DOMAIN: Record<string, string>;
+interface BudgetEnvBounds {
+    min?: number;
+    max?: number;
+}
+export declare function readBudgetEnvNumber(name: string, fallback: number, bounds?: BudgetEnvBounds): number;
+export declare const DEFAULT_TOKEN_BUDGET_ASSUMPTIONS: {
+    tokensPerHour: number;
+    inputShare: number;
+    cachedInputShare: number;
+    contingencyMultiplier: number;
+    roundingStepUsd: number;
+};
+export declare function pickStringArray(record: Record<string, unknown>, keys: string[]): string[];
+export declare function dedupeStrings(items: string[]): string[];
+export declare function isTodoStatus(status: string): boolean;
+export declare function isInProgressStatus(status: string): boolean;
+export declare function isDispatchableWorkstreamStatus(status: string): boolean;
+export declare function isDoneStatus(status: string): boolean;
+export declare function listEntitiesSafe(client: OrgXClient, type: MissionControlNodeType, filters: Record<string, unknown>): Promise<{
+    items: Entity[];
+    warning: string | null;
+}>;
+export declare function buildMissionControlGraph(client: OrgXClient, initiativeId: string, options?: {
+    initiativeEntity?: Entity | null;
+}): Promise<{
+    initiative: {
+        id: string;
+        title: string;
+        status: string;
+        summary: string | null;
+        assignedAgents: MissionControlAssignedAgent[];
+    };
+    nodes: MissionControlNode[];
+    edges: MissionControlEdge[];
+    recentTodos: string[];
+    degraded: string[];
+}>;
+export declare function normalizeEntityMutationPayload(payload: Record<string, unknown>): Record<string, unknown>;
+export declare function resolveAutoAssignments(input: {
+    client: OrgXClient;
+    entityId: string;
+    entityType: string;
+    initiativeId: string | null;
+    title: string;
+    summary: string | null;
+}): Promise<{
+    ok: boolean;
+    assignment_source: "orchestrator" | "fallback" | "manual";
+    assigned_agents: MissionControlAssignedAgent[];
+    warnings: string[];
+    updated_entity?: Entity;
+}>;
+export declare function normalizeExecutionDomain(value: string | null | undefined): string | null;
+export declare function inferExecutionDomainFromText(...values: Array<string | null | undefined>): string;
+export declare function deriveExecutionPolicy(taskNode: MissionControlNode, workstreamNode: MissionControlNode | null): {
+    domain: string;
+    requiredSkills: string[];
+};
+export declare function spawnGuardIsRateLimited(result: unknown): boolean;
+export declare function summarizeSpawnGuardBlockReason(result: unknown): string;
+export {};