@wowok/agent-mcp 2.6.3 → 2.6.4

package/dist/project/mode-actions.js

@@ -0,0 +1,309 @@
+import { getIndustryModeRegistry, getMetricRegistry, getConstraintRegistry, } from "../extensions/index.js";
+import { inferTraitsFromDescription, findSimilarIndustries, } from "../knowledge/industry-generalizer.js";
+import { searchExamples } from "../schema-query/index.js";
+const LOCAL_MODE_OWNER = "local";
+const RM1_11_NODE_REGEX = /(^|_)(disputed?|refund(?:ed)?|arbitration|arb)(_|$)/i;
+function validateMachineShape(machineShape, fieldName) {
+    const violations = [];
+    if (!Array.isArray(machineShape))
+        return violations;
+    const seen = new Set();
+    for (const node of machineShape) {
+        const name = node?.name;
+        if (typeof name !== "string" || !name) {
+            violations.push(`${fieldName}: every node must have a non-empty string 'name'`);
+            continue;
+        }
+        if (seen.has(name)) {
+            violations.push(`${fieldName}: duplicate node name '${name}' (R-M1-10)`);
+        }
+        seen.add(name);
+        if (RM1_11_NODE_REGEX.test(name)) {
+            violations.push(`${fieldName}: node '${name}' violates R-M1-11 — dispute/refund flows must NOT be ` +
+                `modeled as Machine nodes. Disputes flow through Service.arbitrations → Arbitration.dispute() ` +
+                `independently of the Machine. Use business-state nodes (e.g. 'cancelled', 'return_approved') ` +
+                `and route fund refunds via Allocator triggered by those states.`);
+        }
+    }
+    return violations;
+}
+export function handleRecommendIndustry(v) {
+    const intent = (v.intent ?? v.project_description ?? v.project_name ?? "").trim();
+    if (!intent) {
+        throw new Error("recommend_industry requires 'intent' (business description text). " +
+            "Example: intent='I rent cameras to photographers with deposit and damage inspection'.");
+    }
+    const inference = inferTraitsFromDescription(intent);
+    const matches = findSimilarIndustries(inference.traits, 3);
+    const recommendations = matches.map((m) => {
+        const examples = searchExamples(m.industry).slice(0, 3).map((e) => ({
+            file: e.file,
+            title: e.title,
+            operation_type: e.operation_type,
+            verified: e.verified,
+        }));
+        return {
+            industry: m.industry,
+            similarity: m.similarity,
+            matched_traits: m.matched_traits,
+            reference_examples: examples,
+        };
+    });
+    const top = recommendations[0];
+    return {
+        action: "recommend_industry",
+        intent,
+        inferred_traits: inference.traits,
+        inference_confidence: inference.confidence,
+        matched_keywords: inference.matched_keywords,
+        recommendations,
+        hint: top
+            ? `Top match: '${top.industry}' (similarity ${(top.similarity * 100).toFixed(0)}%). ` +
+                `Create the project with project_operation action='create_project' project_industry='${top.industry}' ` +
+                `to get a ready-made blueprint (~10 draft objects + graph edges), or choose another industry from ` +
+                `'recommendations', or use project_industry='custom' with skip_templates=true to build from scratch. ` +
+                `Review reference examples via schema_query action='search_examples' query='<industry>'.`
+            : "No similar industry found. Use project_industry='custom' with skip_templates=true to build from scratch.",
+    };
+}
+export async function handleListModes() {
+    const registry = getIndustryModeRegistry();
+    const builtin = registry.listModes()
+        .filter((m) => m.source === "builtin")
+        .map((m) => ({
+        name: m.name,
+        display_name: m.display_name,
+        version: m.version,
+        key_risk: m.key_risk,
+        machine_nodes: m.machine_shape.map((n) => n.name),
+        similar_industries: m.similar_industries ?? [],
+    }));
+    const userModes = (await registry.listUserModes(LOCAL_MODE_OWNER)).map((m) => ({
+        name: m.name,
+        display_name: m.display_name,
+        version: m.version,
+        derived_from: m.derived_from ?? null,
+        key_risk: m.key_risk,
+        machine_nodes: m.machine_shape.map((n) => n.name),
+        evolution_history: (m.evolution_history ?? []).map((h) => ({
+            version: h.version,
+            changed_at: h.changed_at,
+            changes: h.changes,
+        })),
+    }));
+    return {
+        action: "list_modes",
+        builtin_modes: builtin,
+        user_modes: userModes,
+        owner: LOCAL_MODE_OWNER,
+        hint: "Use a builtin mode name as project_industry in create_project. " +
+            "Use derive_user_mode to customize a builtin mode, or register_user_mode for a fully custom mode. " +
+            "User modes are referenced as '<name>' in derive/evolve/unregister actions.",
+    };
+}
+export async function handleDeriveUserMode(v) {
+    const source = requireField(v.mode_source, "mode_source");
+    const newName = requireField(v.mode_name, "mode_name");
+    const changes = v.mode_changes ?? {};
+    const violations = validateMachineShape(changes.machine_shape, "mode_changes.machine_shape");
+    if (violations.length > 0) {
+        throw new Error(`derive_user_mode blocked:\n${violations.join("\n")}`);
+    }
+    const registry = getIndustryModeRegistry();
+    const derived = await registry.deriveMode(source, changes, LOCAL_MODE_OWNER, newName, v.mode_display_name);
+    if (!derived) {
+        throw new Error(`derive_user_mode failed: source mode '${source}' not found, or name '${newName}' conflicts ` +
+            `with a builtin/existing user mode. Call list_modes to see available names.`);
+    }
+    return {
+        action: "derive_user_mode",
+        mode: summarizeUserMode(derived),
+        hint: `Mode '${newName}' derived from '${source}'. Use it as project_industry in create_project ` +
+            `(applyTemplate resolves user modes via 'local:${newName}'). Iterate with evolve_user_mode.`,
+    };
+}
+export async function handleEvolveUserMode(v) {
+    const name = requireField(v.mode_name, "mode_name");
+    const description = requireField(v.mode_change_description, "mode_change_description");
+    const changes = v.mode_changes ?? {};
+    const violations = validateMachineShape(changes.machine_shape, "mode_changes.machine_shape");
+    if (violations.length > 0) {
+        throw new Error(`evolve_user_mode blocked:\n${violations.join("\n")}`);
+    }
+    const registry = getIndustryModeRegistry();
+    const evolved = await registry.evolveMode(name, changes, LOCAL_MODE_OWNER, description, v.mode_bump_version ?? true);
+    if (!evolved) {
+        throw new Error(`evolve_user_mode failed: user mode '${name}' not found for owner '${LOCAL_MODE_OWNER}'. ` +
+            `Call list_modes to see your modes.`);
+    }
+    return {
+        action: "evolve_user_mode",
+        mode: summarizeUserMode(evolved),
+        hint: `Mode '${name}' evolved to ${evolved.version}. Evolution history recorded.`,
+    };
+}
+export async function handleRegisterUserMode(v) {
+    const name = requireField(v.mode_name, "mode_name");
+    const payload = v.mode_changes ?? {};
+    const missing = [];
+    if (!Array.isArray(payload.machine_shape) || payload.machine_shape.length === 0) {
+        missing.push("machine_shape (non-empty array of {name, role})");
+    }
+    if (typeof payload.key_risk !== "string" || !payload.key_risk) {
+        missing.push("key_risk (string describing the industry's key risk)");
+    }
+    if (missing.length > 0) {
+        throw new Error(`register_user_mode requires these fields in mode_changes: ${missing.join(", ")}. ` +
+            `Tip: derive_user_mode from a builtin mode is usually easier than registering from scratch.`);
+    }
+    const violations = validateMachineShape(payload.machine_shape, "mode_changes.machine_shape");
+    if (violations.length > 0) {
+        throw new Error(`register_user_mode blocked:\n${violations.join("\n")}`);
+    }
+    const registry = getIndustryModeRegistry();
+    const general = registry.getMode("general");
+    if (!general)
+        throw new Error("Builtin mode 'general' not registered — cannot build custom mode defaults");
+    const mode = {
+        ...general,
+        ...payload,
+        name,
+        display_name: v.mode_display_name ?? name,
+        version: "v1",
+        source: "custom",
+        owner: LOCAL_MODE_OWNER,
+        derived_from: undefined,
+        evolution_history: [],
+    };
+    const ok = await registry.registerUserMode(mode, LOCAL_MODE_OWNER);
+    if (!ok) {
+        throw new Error(`register_user_mode failed: name '${name}' conflicts with a builtin/existing user mode, ` +
+            `or payload is invalid. Call list_modes to see available names.`);
+    }
+    return {
+        action: "register_user_mode",
+        mode: summarizeUserMode(mode),
+        hint: `Custom mode '${name}' registered. Use it as project_industry in create_project.`,
+    };
+}
+export async function handleUnregisterUserMode(v) {
+    const name = requireField(v.mode_name, "mode_name");
+    const registry = getIndustryModeRegistry();
+    const ok = await registry.unregisterUserMode(name, LOCAL_MODE_OWNER);
+    if (!ok) {
+        throw new Error(`unregister_user_mode failed: user mode '${name}' not found for owner '${LOCAL_MODE_OWNER}'.`);
+    }
+    return {
+        action: "unregister_user_mode",
+        removed: true,
+        mode_name: name,
+    };
+}
+export function handleRegisterCustomMetric(v) {
+    const id = requireField(v.metric_id, "metric_id");
+    const displayName = requireField(v.metric_display_name, "metric_display_name");
+    const description = requireField(v.metric_description, "metric_description");
+    const type = requireField(v.metric_type, "metric_type");
+    const scale = requireField(v.metric_scale, "metric_scale");
+    const ok = getMetricRegistry().registerCustomMetric(id, displayName, description, type, scale, LOCAL_MODE_OWNER, v.metric_weight);
+    if (!ok) {
+        throw new Error(`register_custom_metric failed: metric_id '${id}' already exists or fields are invalid.`);
+    }
+    return {
+        action: "register_custom_metric",
+        metric: {
+            metric_id: id,
+            display_name: displayName,
+            description,
+            type,
+            scale,
+            weight: v.metric_weight ?? 1.0,
+            scope: "custom",
+            owner: LOCAL_MODE_OWNER,
+        },
+        hint: `Custom metric '${id}' registered globally — all modes can reference it via custom_metrics.`,
+    };
+}
+export function handleRegisterCustomConstraint(v) {
+    const id = requireField(v.constraint_id, "constraint_id");
+    const displayName = requireField(v.constraint_display_name, "constraint_display_name");
+    const description = requireField(v.constraint_description, "constraint_description");
+    const rule = v.constraint_rule;
+    if (!rule || typeof rule !== "object" || !("type" in rule)) {
+        throw new Error("constraint_rule is required and must be one of: " +
+            "{type:'capability_required', capability_id} | {type:'capability_forbidden', capability_id} | " +
+            "{type:'numeric_limit', field, max?, min?} | {type:'condition_required', condition, ai_evaluated:true}");
+    }
+    const ok = getConstraintRegistry().registerCustomConstraint(id, displayName, description, rule, LOCAL_MODE_OWNER, v.constraint_severity ?? "soft", v.constraint_on_violation ?? "warn");
+    if (!ok) {
+        throw new Error(`register_custom_constraint failed: constraint_id '${id}' already exists or rule is invalid.`);
+    }
+    return {
+        action: "register_custom_constraint",
+        constraint: {
+            constraint_id: id,
+            display_name: displayName,
+            description,
+            rule,
+            severity: v.constraint_severity ?? "soft",
+            on_violation: v.constraint_on_violation ?? "warn",
+            scope: "custom",
+            owner: LOCAL_MODE_OWNER,
+        },
+        hint: `Custom constraint '${id}' registered. 'hard' constraints block applyTemplate on violation; 'soft' only warn.`,
+    };
+}
+export function handleListMetricsConstraints(v) {
+    const metrics = getMetricRegistry().listMetrics({
+        type: v.metric_type_filter,
+        scope: v.scope_filter,
+    }).map((m) => ({
+        metric_id: m.metric_id,
+        display_name: m.display_name,
+        description: m.description,
+        type: m.type,
+        scale: m.scale,
+        weight: m.weight,
+        scope: m.scope,
+    }));
+    const constraints = getConstraintRegistry().listConstraints({
+        scope: v.scope_filter,
+    }).map((c) => ({
+        constraint_id: c.constraint_id,
+        display_name: c.display_name,
+        description: c.description,
+        rule: c.rule,
+        severity: c.severity,
+        on_violation: c.on_violation,
+        scope: c.scope,
+    }));
+    return {
+        action: "list_metrics_constraints",
+        metrics,
+        constraints,
+        hint: "Register custom entries via register_custom_metric / register_custom_constraint. " +
+            "Filter with metric_type_filter ('risk'|'benefit') or scope_filter ('builtin'|'custom').",
+    };
+}
+function requireField(value, fieldName) {
+    if (value === undefined || value === null || (typeof value === "string" && !value.trim())) {
+        throw new Error(`'${fieldName}' is required for this action`);
+    }
+    return value;
+}
+function summarizeUserMode(m) {
+    return {
+        name: m.name,
+        display_name: m.display_name,
+        version: m.version,
+        derived_from: m.derived_from ?? null,
+        owner: m.owner,
+        key_risk: m.key_risk,
+        machine_nodes: m.machine_shape.map((n) => n.name),
+        evolution_history: (m.evolution_history ?? []).map((h) => ({
+            version: h.version,
+            changed_at: h.changed_at,
+            changes: h.changes,
+        })),
+    };
+}

package/dist/project/participation-radar.d.ts

@@ -0,0 +1,18 @@
+import type { z } from "zod";
+import { type OrderRadarResult } from "../participation/radar-core.js";
+import type { ProjectOperationInputSchema } from "../schema/project/index.js";
+type ProjectInput = z.infer<typeof ProjectOperationInputSchema>;
+export declare function handleParticipationRadar(v: ProjectInput): Promise<{
+    action: "participation_radar";
+    account: string;
+    orders_analyzed: number;
+    actionable: OrderRadarResult[];
+    waiting: OrderRadarResult[];
+    all_pending_claims: (import("../participation/radar-core.js").PendingClaim & {
+        progress: string;
+    })[];
+    unread_messages_total: number;
+    data_gaps: string[];
+    summary: string;
+}>;
+export {};