@wowok/agent-mcp 2.4.3 → 2.5.1

package/dist/knowledge/permission-context.js

@@ -0,0 +1,224 @@
+import { USER_DEFINED_PERM_INDEX_START, MAX_ENTITY_COUNT, MAX_PERM_FOR_ENTITY, MAX_ADMIN_COUNT, } from "@wowok/wowok";
+import { PERMISSION_SCENES, findSceneByPermissionIndex, inferSceneFromIntent, getScenesByHostObject, getAllBuiltinPermissions, } from "./permission-ledger.js";
+import { getTemplatesByScene, } from "./permission-templates.js";
+import { matchSemanticPattern, } from "./permission-translation.js";
+import { getAllRiskRules, assessPermissionRisks, } from "./permission-risk.js";
+import { initPuzzleFromIntent, checkPuzzleCompleteness, } from "./permission-puzzle.js";
+import { PERMISSION_PUBLISH_CHECKLIST, PERMISSION_CONFIRMATION_QUESTIONS, } from "./permission-confirm.js";
+export const PERMISSION_CONTEXT_VERSION = "1.0.0";
+export function buildPermissionContext(input) {
+    const max_length = input.max_length ?? 4000;
+    let matched_scene;
+    if (input.intent) {
+        matched_scene = inferSceneFromIntent(input.intent);
+    }
+    else if (input.target_permission_index !== undefined) {
+        matched_scene = findSceneByPermissionIndex(input.target_permission_index);
+    }
+    else if (input.target_host_object) {
+        const scenes = getScenesByHostObject(input.target_host_object);
+        if (scenes.length > 0)
+            matched_scene = scenes[0];
+    }
+    let matched_template;
+    if (matched_scene) {
+        const templates = getTemplatesByScene(matched_scene.id);
+        if (templates.length > 0)
+            matched_template = templates[0];
+    }
+    let matched_pattern;
+    if (input.intent) {
+        const patterns = matchSemanticPattern(input.intent);
+        if (patterns.length > 0)
+            matched_pattern = patterns[0];
+    }
+    let puzzle_state;
+    let puzzle_completeness;
+    if (input.mode === "initial_design" && input.intent) {
+        puzzle_state = initPuzzleFromIntent({ rule_sentence: input.intent });
+        puzzle_completeness = checkPuzzleCompleteness(puzzle_state);
+    }
+    const relevant_risks = filterRiskRules(input.mode, input.stakeholder, matched_scene);
+    let risk_assessment;
+    if (input.mode === "pre_publish" && input.permission_json) {
+        const ctx = {
+            object: input.permission_json.object,
+            admin: input.permission_json.admin,
+            table: input.permission_json.table,
+            entity: input.permission_json.entity,
+            remark: input.permission_json.remark,
+            apply: input.permission_json.apply,
+            builder: input.permission_json.builder,
+            um: input.permission_json.um,
+        };
+        risk_assessment = assessPermissionRisks(ctx);
+    }
+    const relevant_checklist = filterChecklist(input.mode);
+    const relevant_questions = filterQuestions(input.mode);
+    const relevant_builtin_permissions = matched_scene
+        ? matched_scene.builtin_indexes
+        : getAllBuiltinPermissions();
+    const cross_object_refs = buildCrossObjectRefs(matched_scene);
+    const onchain_constraints = buildOnchainConstraints();
+    const rendering_hints = buildRenderingHints(input.mode, max_length, !!input.permission_json?.builder);
+    return {
+        version: PERMISSION_CONTEXT_VERSION,
+        mode: input.mode,
+        stakeholder_perspective: input.stakeholder,
+        matched_scene,
+        matched_template,
+        matched_pattern,
+        puzzle_state,
+        puzzle_completeness,
+        relevant_risks,
+        risk_assessment,
+        relevant_checklist,
+        relevant_questions,
+        relevant_builtin_permissions,
+        cross_object_refs,
+        onchain_constraints,
+        rendering_hints,
+    };
+}
+function filterRiskRules(mode, stakeholder, scene) {
+    let rules = getAllRiskRules();
+    if (mode === "initial_design") {
+        return rules.filter(r => r.category === "structural" || r.category === "authority");
+    }
+    if (mode === "pre_publish") {
+        return rules;
+    }
+    if (mode === "stakeholder_review" && stakeholder) {
+        if (stakeholder === "owner") {
+            return rules.filter(r => r.category === "authority" || r.category === "lifecycle");
+        }
+        if (stakeholder === "admin") {
+            return rules.filter(r => r.category === "structural" || r.category === "semantic");
+        }
+    }
+    return rules;
+}
+function filterChecklist(mode) {
+    if (mode === "initial_design") {
+        return PERMISSION_PUBLISH_CHECKLIST.filter(i => ["C-P-01", "C-P-02", "C-P-03", "C-P-04"].includes(i.id));
+    }
+    return PERMISSION_PUBLISH_CHECKLIST;
+}
+function filterQuestions(mode) {
+    if (mode === "pre_publish") {
+        return PERMISSION_CONFIRMATION_QUESTIONS;
+    }
+    if (mode === "post_publish_modify") {
+        return PERMISSION_CONFIRMATION_QUESTIONS.filter(q => q.id !== "QP5");
+    }
+    return [];
+}
+function buildCrossObjectRefs(scene) {
+    if (!scene)
+        return [];
+    const refs = [];
+    for (const s of PERMISSION_SCENES) {
+        if (s.host_object === scene.host_object || s.id === scene.id)
+            continue;
+        refs.push({
+            object: s.host_object,
+            field: "permission",
+            scene_id: s.id,
+            description: `${s.host_object} uses permission indexes ${s.permission_index_range}`,
+        });
+    }
+    return refs;
+}
+function buildOnchainConstraints() {
+    return [
+        { name: "USER_DEFINED_PERM_INDEX_START", value: USER_DEFINED_PERM_INDEX_START, description: "Custom permission indexes must be >= this value" },
+        { name: "MAX_ENTITY_COUNT", value: MAX_ENTITY_COUNT, description: "Maximum entities per Permission" },
+        { name: "MAX_PERM_FOR_ENTITY", value: MAX_PERM_FOR_ENTITY, description: "Maximum permission indexes per entity" },
+        { name: "MAX_ADMIN_COUNT", value: MAX_ADMIN_COUNT, description: "Maximum admins per Permission" },
+    ];
+}
+function buildRenderingHints(mode, max_length, hasTransfer) {
+    return {
+        include_puzzle_template: mode === "initial_design",
+        include_risk_details: mode === "pre_publish" || mode === "stakeholder_review",
+        include_questions: mode === "pre_publish",
+        include_immutability_warning: mode === "post_publish_modify",
+        include_transfer_warning: hasTransfer,
+        max_length,
+    };
+}
+export function buildPromptFromPermissionContext(bundle) {
+    const lines = [];
+    const h = bundle.rendering_hints;
+    lines.push("═══ Permission Context (mode: " + bundle.mode + ") ═══");
+    lines.push("");
+    if (bundle.matched_scene) {
+        lines.push(`Scene: ${bundle.matched_scene.name}`);
+        lines.push(`Host object: ${bundle.matched_scene.host_object}`);
+        lines.push(`Permission range: ${bundle.matched_scene.permission_index_range}`);
+        lines.push("");
+    }
+    if (bundle.matched_template) {
+        lines.push(`Suggested template: ${bundle.matched_template.id} — ${bundle.matched_template.name}`);
+        lines.push("");
+    }
+    if (h.include_puzzle_template && bundle.puzzle_completeness) {
+        const c = bundle.puzzle_completeness;
+        lines.push("─ Puzzle Completeness ──────────────");
+        lines.push(`Complete: ${c.complete ? "YES" : "NO"}`);
+        if (c.missing.length > 0) {
+            lines.push(`Missing: ${c.missing.join(", ")}`);
+        }
+        lines.push(`Next: ${c.next_step}`);
+        lines.push("");
+    }
+    if (h.include_risk_details && bundle.relevant_risks.length > 0) {
+        lines.push(`─ Relevant Risk Rules (${bundle.relevant_risks.length}) ──────────────`);
+        for (const r of bundle.relevant_risks.slice(0, 5)) {
+            lines.push(`  ${r.id} — ${r.trigger}`);
+        }
+        if (bundle.relevant_risks.length > 5) {
+            lines.push(`  ... and ${bundle.relevant_risks.length - 5} more`);
+        }
+        lines.push("");
+    }
+    if (bundle.risk_assessment) {
+        lines.push("─ Risk Assessment ──────────────");
+        lines.push(`Overall: ${bundle.risk_assessment.overall_risk}`);
+        lines.push(`Detected: ${bundle.risk_assessment.risks.length} risk(s)`);
+        lines.push("");
+    }
+    if (bundle.relevant_builtin_permissions.length > 0) {
+        lines.push(`─ Builtin Permissions (${bundle.relevant_builtin_permissions.length}) ──────────────`);
+        for (const p of bundle.relevant_builtin_permissions.slice(0, 8)) {
+            lines.push(`  [${p.index}] ${p.name}: ${p.description}`);
+        }
+        if (bundle.relevant_builtin_permissions.length > 8) {
+            lines.push(`  ... and ${bundle.relevant_builtin_permissions.length - 8} more`);
+        }
+        lines.push("");
+    }
+    if (h.include_transfer_warning) {
+        lines.push("⚠️ TRANSFER OPERATION DETECTED — This is IRREVERSIBLE");
+        lines.push("");
+    }
+    if (bundle.onchain_constraints.length > 0) {
+        lines.push("─ On-chain Constraints ──────────────");
+        for (const c of bundle.onchain_constraints) {
+            lines.push(`  ${c.name} = ${c.value} — ${c.description}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+export function getPermissionContextSummary(bundle) {
+    const parts = [
+        `mode=${bundle.mode}`,
+        `scene=${bundle.matched_scene?.id ?? "none"}`,
+        `risks=${bundle.relevant_risks.length}`,
+        `permissions=${bundle.relevant_builtin_permissions.length}`,
+    ];
+    if (bundle.risk_assessment)
+        parts.push(`overall_risk=${bundle.risk_assessment.overall_risk}`);
+    return parts.join(", ");
+}

package/dist/knowledge/permission-ledger.d.ts

@@ -0,0 +1,38 @@
+export interface PermissionScene {
+    id: string;
+    name: string;
+    host_object: "Service" | "Machine" | "Treasury" | "Arbitration" | "Repository" | "Reward" | "Progress" | "Demand" | "Contact" | "Allocation" | "Standalone";
+    permission_index_range: string;
+    builtin_indexes: BuiltinPermissionEntry[];
+    owner_operations: string[];
+    admin_operations: string[];
+    permission_index_operations: string[];
+    mutable_after_publish: boolean;
+    common_patterns: string[];
+    recommended_templates: string[];
+}
+export interface BuiltinPermissionEntry {
+    index: number;
+    name: string;
+    description: string;
+    governed_operation: string;
+}
+export declare const REPOSITORY_PERMISSIONS: BuiltinPermissionEntry[];
+export declare const REWARD_PERMISSIONS: BuiltinPermissionEntry[];
+export declare const MACHINE_PERMISSIONS: BuiltinPermissionEntry[];
+export declare const PROGRESS_PERMISSIONS: BuiltinPermissionEntry[];
+export declare const TREASURY_PERMISSIONS: BuiltinPermissionEntry[];
+export declare const SERVICE_PERMISSIONS: BuiltinPermissionEntry[];
+export declare const ARBITRATION_PERMISSIONS: BuiltinPermissionEntry[];
+export declare const DEMAND_PERMISSIONS: BuiltinPermissionEntry[];
+export declare const CONTACT_PERMISSIONS: BuiltinPermissionEntry[];
+export declare const PERMISSION_SCENES: PermissionScene[];
+export declare const PERMISSION_LEDGER_VERSION = "1.0.0";
+export declare function getScenesByHostObject(host: PermissionScene["host_object"]): PermissionScene[];
+export declare function findSceneById(id: string): PermissionScene | undefined;
+export declare function findSceneByPermissionIndex(index: number): PermissionScene | undefined;
+export declare function getBuiltinPermissionByIndex(index: number): BuiltinPermissionEntry | undefined;
+export declare function isBuiltinPermission(index: number): boolean;
+export declare function inferSceneFromIntent(intent: string): PermissionScene | undefined;
+export declare function getAllBuiltinPermissions(): BuiltinPermissionEntry[];
+export declare function getPermissionScenesCount(): number;