@wowok/agent-mcp 2.4.1 → 2.5.0

package/dist/project/query.js

@@ -1,35 +1,76 @@
 import { LocalMark } from "@wowok/wowok";
-import { extractProjectPrefix, TAG_PREFIX } from "./namespace.js";
+import { extractAllProjectVersions, TAG_PREFIX } from "./namespace.js";
 export async function listProjects() {
     const marks = await LocalMark.Instance().list(undefined);
     const byProject = new Map();
     for (const m of marks) {
-        const prefix = extractProjectPrefix(m.tags);
-        if (!prefix)
+        const entries = extractAllProjectVersions(m.tags);
+        if (entries.length === 0)
             continue;
-        if (!byProject.has(prefix)) {
-            byProject.set(prefix, { prefix, objectCount: 0, types: [], objects: [] });
+        const byPrefix = new Map();
+        for (const entry of entries) {
+            if (!byPrefix.has(entry.prefix))
+                byPrefix.set(entry.prefix, []);
+            byPrefix.get(entry.prefix).push(entry.version);
         }
-        const proj = byProject.get(prefix);
-        proj.objectCount++;
         const typeTag = m.tags?.find((t) => t.startsWith(TAG_PREFIX.type));
         const type = typeTag?.slice(TAG_PREFIX.type.length);
-        if (type && !proj.types.includes(type))
-            proj.types.push(type);
-        proj.objects.push({ name: m.name, address: m.address, type });
+        for (const [prefix, versions] of byPrefix) {
+            const hasVersioned = versions.some((v) => v !== undefined);
+            const effectiveVersions = hasVersioned
+                ? versions.filter((v) => v !== undefined)
+                : versions;
+            if (!byProject.has(prefix)) {
+                byProject.set(prefix, {
+                    prefix,
+                    objectCount: 0,
+                    types: [],
+                    versions: [],
+                    objects: [],
+                });
+            }
+            const proj = byProject.get(prefix);
+            if (type && !proj.types.includes(type))
+                proj.types.push(type);
+            for (const v of effectiveVersions) {
+                proj.objectCount++;
+                if (v && !proj.versions.includes(v)) {
+                    proj.versions.push(v);
+                }
+                proj.objects.push({
+                    name: m.name,
+                    address: m.address,
+                    type,
+                    version: v,
+                });
+            }
+        }
     }
     return Array.from(byProject.values()).sort((a, b) => b.objectCount - a.objectCount);
 }
 export async function listProjectObjects(prefix) {
-    const marks = await LocalMark.Instance().list({ tags: [`${TAG_PREFIX.project}${prefix}`] });
-    return marks.map((m) => {
+    const marks = await LocalMark.Instance().list(undefined);
+    const results = [];
+    const isVersionedFilter = prefix.includes("_v");
+    for (const m of marks) {
+        const entries = extractAllProjectVersions(m.tags);
+        const matched = entries.find((e) => {
+            if (isVersionedFilter) {
+                return e.version ? `${e.prefix}_${e.version}` === prefix : false;
+            }
+            return e.prefix === prefix;
+        });
+        if (!matched)
+            continue;
         const typeTag = m.tags?.find((t) => t.startsWith(TAG_PREFIX.type));
-        return {
+        results.push({
             name: m.name,
             address: m.address,
             type: typeTag?.slice(TAG_PREFIX.type.length),
-        };
-    });
+            version: matched.version,
+        });
+    }
+    return results;
 }
 export async function listShareableObjects() {
     const marks = await LocalMark.Instance().list({ tags: [`${TAG_PREFIX.shareable}true`] });

package/dist/project/risk-aggregator.d.ts

@@ -0,0 +1,50 @@
+import type { ProjectObjectType, IndustryMode } from "./namespace.js";
+import type { ObjectPuzzleEntry } from "./business-puzzle.js";
+export type RiskSeverity = "CRITICAL" | "HIGH" | "MEDIUM" | "LOW" | "INFO";
+export interface RiskAggregationInput {
+    project_prefix: string;
+    version: string;
+    industry?: IndustryMode | string;
+    puzzles: Record<string, ObjectPuzzleEntry>;
+    severity_threshold?: RiskSeverity;
+    user_confirmed_high_risks?: string[];
+}
+export interface AggregatedRisk {
+    risk_rule_id: string;
+    object_type: ProjectObjectType;
+    entry_id: string;
+    severity: RiskSeverity;
+    message: string;
+    fix_suggestion: string;
+    details?: {
+        field_path?: string;
+        actual_value?: unknown;
+        expected_value?: unknown;
+        rule_source?: string;
+    };
+}
+export interface RiskAggregationResult {
+    namespace: {
+        prefix: string;
+        version: string;
+        industry?: IndustryMode;
+    };
+    findings: AggregatedRisk[];
+    severity_summary: Record<RiskSeverity, number>;
+    status: "RISK_PASSED" | "RISK_BLOCKED" | "RISK_PENDING_CONFIRM" | "RISK_CANCELLED";
+    pending_confirmations?: Array<{
+        risk_rule_id: string;
+        description: string;
+        fix_suggestion: string;
+        object_type: ProjectObjectType;
+        entry_id: string;
+    }>;
+    calibrated_at: number;
+    warnings: string[];
+}
+export declare function aggregateProjectRisks(input: RiskAggregationInput): RiskAggregationResult;
+export declare function sortFindings(findings: AggregatedRisk[]): AggregatedRisk[];
+export declare function countBySeverity(findings: AggregatedRisk[]): Record<RiskSeverity, number>;
+export declare function determineStatus(severity_summary: Record<RiskSeverity, number>, threshold: RiskSeverity, user_confirmed_high_risks: string[], findings: AggregatedRisk[]): RiskAggregationResult["status"];
+export declare function getCriticalRisks(result: RiskAggregationResult): AggregatedRisk[];
+export declare function summarizeRiskReport(result: RiskAggregationResult): string;

package/dist/project/risk-aggregator.js

@@ -0,0 +1,280 @@
+import { assessServiceRisks, assessMachineRisks, assessAllocationRisks, assessTreasuryRisks, assessArbitrationRisks, assessRewardRisks, assessProgressRisks, assessOrderRisks, assessGuardRisks, checkContactRisks, checkResourceRisks, checkPaymentRisks, checkArbRisks, checkPersonalRisks, checkUtilRisks, checkRegistrarRisks, checkBridgeRisks, checkProofRisks, checkRepositoryRisks, checkDemandRisks, } from "../knowledge/index.js";
+import { assessPermissionRisks } from "../knowledge/permission-risk.js";
+const SEVERITY_ORDER = {
+    CRITICAL: 0,
+    HIGH: 1,
+    MEDIUM: 2,
+    LOW: 3,
+    INFO: 4,
+};
+const ALL_SEVERITIES = ["CRITICAL", "HIGH", "MEDIUM", "LOW", "INFO"];
+function normalizeSeverity(level) {
+    if (typeof level !== "string")
+        return "INFO";
+    const upper = level.toUpperCase();
+    return ALL_SEVERITIES.includes(upper) ? upper : "INFO";
+}
+function extractRiskId(risk, fallback) {
+    if (!risk || typeof risk !== "object")
+        return fallback;
+    return String(risk.id ?? risk.risk_rule_id ?? risk.rule_id ?? fallback);
+}
+function extractRiskMessage(risk) {
+    if (!risk || typeof risk !== "object")
+        return "(no message)";
+    return String(risk.title ?? risk.message ?? risk.description ?? risk.trigger ?? "(no message)");
+}
+function extractFixSuggestion(risk) {
+    if (!risk || typeof risk !== "object")
+        return "";
+    return String(risk.mitigation ?? risk.fix_suggestion ?? risk.suggestion ?? "");
+}
+function toAggregatedRisk(risk, objectType, entryId) {
+    return {
+        risk_rule_id: extractRiskId(risk, `R-${objectType.toUpperCase()}-?`),
+        object_type: objectType,
+        entry_id: entryId,
+        severity: normalizeSeverity(risk?.level ?? risk?.severity),
+        message: extractRiskMessage(risk),
+        fix_suggestion: extractFixSuggestion(risk),
+        details: risk?.evidence
+            ? { field_path: String(risk.evidence) }
+            : undefined,
+    };
+}
+function isL1L2Object(objType) {
+    return [
+        "service", "machine", "allocation", "treasury", "arb",
+        "reward", "progress", "order", "permission", "guard",
+    ].includes(objType);
+}
+function buildL1L2Dispatch() {
+    const safeAssess = (puzzle, fn) => {
+        try {
+            const ctx = puzzle ?? {};
+            const result = fn(ctx);
+            if (Array.isArray(result))
+                return result;
+            if (result && typeof result === "object") {
+                const r = result.risks;
+                if (Array.isArray(r))
+                    return r;
+            }
+            return [];
+        }
+        catch {
+            return [];
+        }
+    };
+    return {
+        service: { assess: (p) => safeAssess(p, assessServiceRisks) },
+        machine: { assess: (p) => safeAssess(p, (ctx) => assessMachineRisks(ctx, {})) },
+        allocation: { assess: (p) => safeAssess(p, assessAllocationRisks) },
+        treasury: { assess: (p) => safeAssess(p, assessTreasuryRisks) },
+        arb: { assess: (p) => safeAssess(p, assessArbitrationRisks) },
+        reward: { assess: (p) => safeAssess(p, (ctx) => assessRewardRisks(ctx)) },
+        progress: { assess: (p) => safeAssess(p, (ctx) => assessProgressRisks(ctx)) },
+        order: { assess: (p) => safeAssess(p, assessOrderRisks) },
+        permission: { assess: (p) => safeAssess(p, assessPermissionRisks) },
+        guard: {
+            assess: (p) => {
+                try {
+                    const result = assessGuardRisks({
+                        table: [],
+                        root: undefined,
+                    });
+                    if (Array.isArray(result))
+                        return result;
+                    if (result && typeof result === "object") {
+                        const r = result.risks;
+                        if (Array.isArray(r))
+                            return r;
+                    }
+                    return [];
+                }
+                catch {
+                    return [];
+                }
+            },
+        },
+    };
+}
+function buildL3Dispatch() {
+    const safeCheck = (puzzle, fn) => {
+        try {
+            const ctx = puzzle ?? {};
+            const result = fn(ctx);
+            if (Array.isArray(result))
+                return result;
+            return [];
+        }
+        catch {
+            return [];
+        }
+    };
+    return {
+        contact: { check: (p) => safeCheck(p, checkContactRisks) },
+        resource: { check: (p) => safeCheck(p, checkResourceRisks) },
+        payment: { check: (p) => safeCheck(p, checkPaymentRisks) },
+        arb: { check: (p) => safeCheck(p, checkArbRisks) },
+        personal: { check: (p) => safeCheck(p, checkPersonalRisks) },
+        util: { check: (p) => safeCheck(p, checkUtilRisks) },
+        registrar: { check: (p) => safeCheck(p, checkRegistrarRisks) },
+        bridge: { check: (p) => safeCheck(p, checkBridgeRisks) },
+        proof: { check: (p) => safeCheck(p, checkProofRisks) },
+        repository: { check: (p) => safeCheck(p, checkRepositoryRisks) },
+        demand: { check: (p) => safeCheck(p, checkDemandRisks) },
+    };
+}
+export function aggregateProjectRisks(input) {
+    const warnings = [];
+    if (!input || !input.project_prefix) {
+        warnings.push("input.project_prefix is empty");
+    }
+    const puzzles = input?.puzzles ?? {};
+    const findings = [];
+    const l1l2 = buildL1L2Dispatch();
+    const l3 = buildL3Dispatch();
+    for (const [objTypeStr, entry] of Object.entries(puzzles)) {
+        const objType = objTypeStr;
+        const entryId = `${input.project_prefix ?? "project"}_${objType}`;
+        const puzzle = entry?.puzzle;
+        if (isL1L2Object(objType)) {
+            const d = l1l2[objType];
+            if (!d) {
+                warnings.push(`No L1/L2 risk dispatcher for '${objType}'`);
+                continue;
+            }
+            const rawRisks = d.assess(puzzle);
+            for (const r of rawRisks) {
+                findings.push(toAggregatedRisk(r, objType, entryId));
+            }
+        }
+        else {
+            const d = l3[objType];
+            if (!d) {
+                warnings.push(`No L3 risk dispatcher for '${objType}'`);
+                continue;
+            }
+            const rawRisks = d.check(puzzle);
+            for (const r of rawRisks) {
+                findings.push(toAggregatedRisk(r, objType, entryId));
+            }
+        }
+    }
+    sortFindings(findings);
+    const severity_summary = countBySeverity(findings);
+    const threshold = input.severity_threshold ?? "HIGH";
+    const status = determineStatus(severity_summary, threshold, input.user_confirmed_high_risks ?? [], findings);
+    let pending_confirmations;
+    if (status === "RISK_PENDING_CONFIRM") {
+        pending_confirmations = findings
+            .filter((f) => f.severity === "HIGH")
+            .filter((f) => !(input.user_confirmed_high_risks ?? []).includes(f.risk_rule_id))
+            .map((f) => ({
+            risk_rule_id: f.risk_rule_id,
+            description: f.message,
+            fix_suggestion: f.fix_suggestion,
+            object_type: f.object_type,
+            entry_id: f.entry_id,
+        }));
+    }
+    return {
+        namespace: {
+            prefix: input.project_prefix ?? "",
+            version: input.version ?? "",
+            industry: input.industry ?? "general",
+        },
+        findings,
+        severity_summary,
+        status,
+        pending_confirmations,
+        calibrated_at: Date.now(),
+        warnings,
+    };
+}
+export function sortFindings(findings) {
+    return findings.sort((a, b) => {
+        const sevDiff = SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity];
+        if (sevDiff !== 0)
+            return sevDiff;
+        if (a.object_type !== b.object_type) {
+            return a.object_type.localeCompare(b.object_type);
+        }
+        return a.risk_rule_id.localeCompare(b.risk_rule_id);
+    });
+}
+export function countBySeverity(findings) {
+    const counts = {
+        CRITICAL: 0,
+        HIGH: 0,
+        MEDIUM: 0,
+        LOW: 0,
+        INFO: 0,
+    };
+    for (const f of findings) {
+        counts[f.severity]++;
+    }
+    return counts;
+}
+export function determineStatus(severity_summary, threshold, user_confirmed_high_risks, findings) {
+    if (severity_summary.CRITICAL > 0)
+        return "RISK_BLOCKED";
+    const thresholdLevel = SEVERITY_ORDER[threshold];
+    if (severity_summary.HIGH > 0 && thresholdLevel <= SEVERITY_ORDER.HIGH) {
+        const unconfirmed = findings.filter((f) => f.severity === "HIGH" && !user_confirmed_high_risks.includes(f.risk_rule_id));
+        if (unconfirmed.length > 0)
+            return "RISK_PENDING_CONFIRM";
+    }
+    if (severity_summary.MEDIUM > 0 && thresholdLevel <= SEVERITY_ORDER.MEDIUM) {
+        return "RISK_BLOCKED";
+    }
+    if (severity_summary.LOW > 0 && thresholdLevel <= SEVERITY_ORDER.LOW) {
+        return "RISK_BLOCKED";
+    }
+    return "RISK_PASSED";
+}
+export function getCriticalRisks(result) {
+    if (!result?.findings)
+        return [];
+    return result.findings.filter((f) => f.severity === "CRITICAL");
+}
+export function summarizeRiskReport(result) {
+    if (!result)
+        return "(no result)";
+    const lines = [];
+    lines.push(`# Risk Aggregation Report`);
+    lines.push("");
+    lines.push(`- Project: ${result.namespace.prefix}_${result.namespace.version}`);
+    lines.push(`- Status: ${result.status}`);
+    lines.push(`- Calibrated at: ${new Date(result.calibrated_at).toISOString()}`);
+    lines.push("");
+    lines.push("## Severity Summary");
+    lines.push("");
+    lines.push("| Severity | Count |");
+    lines.push("|----------|-------|");
+    for (const sev of ALL_SEVERITIES) {
+        lines.push(`| ${sev} | ${result.severity_summary[sev] ?? 0} |`);
+    }
+    lines.push("");
+    if (result.findings.length === 0) {
+        lines.push("No risks found.");
+        return lines.join("\n");
+    }
+    lines.push("## Findings (sorted by severity)");
+    lines.push("");
+    for (const f of result.findings) {
+        lines.push(`- **[${f.severity}] ${f.risk_rule_id}** (${f.object_type} / ${f.entry_id})`);
+        lines.push(`  - ${f.message}`);
+        if (f.fix_suggestion) {
+            lines.push(`  - Fix: ${f.fix_suggestion}`);
+        }
+    }
+    if (result.warnings.length > 0) {
+        lines.push("");
+        lines.push("## Warnings");
+        for (const w of result.warnings)
+            lines.push(`- ${w}`);
+    }
+    return lines.join("\n");
+}

package/dist/project/substep-trace.d.ts

@@ -0,0 +1,130 @@
+import type { ProjectObjectType } from "./namespace.js";
+export type SubstepNetwork = "testnet" | "mainnet";
+export type SubstepStatus = "PENDING" | "SUCCESS" | "FAILED" | "SKIPPED";
+export interface OutputRef {
+    substep_id: string;
+    field_path: string;
+}
+export interface SubstepRecord {
+    step_id: string;
+    parent_step: string;
+    object_type: ProjectObjectType;
+    entry_id: string;
+    operation_type: string;
+    network: SubstepNetwork;
+    input: {
+        data: Record<string, unknown>;
+        input_refs: string[];
+    };
+    output?: {
+        object_id?: string;
+        tx_digest?: string;
+        [key: string]: unknown;
+    };
+    timestamp: number;
+    status: SubstepStatus;
+    failure_reason?: string;
+    dependencies: {
+        input_refs: string[];
+        output_refs: OutputRef[];
+    };
+    retry_info?: {
+        original_step_id: string;
+        retry_count: number;
+        retry_reason: string;
+    };
+}
+export interface SubstepEdge {
+    source: string;
+    target: string;
+    field_path: string;
+}
+export interface SubstepDAG {
+    namespace: {
+        prefix: string;
+        version: string;
+    };
+    network: SubstepNetwork;
+    substeps: SubstepRecord[];
+    edges: SubstepEdge[];
+    topological_order: string[];
+}
+export interface DanglingInput {
+    substep_id: string;
+    missing_ref: string;
+    field_path: string;
+}
+export interface CircularRef {
+    cycle: string[];
+}
+export interface MissingOutput {
+    substep_id: string;
+    expected_field: string;
+    dependent_substeps: string[];
+}
+export interface CrossStepBreak {
+    source_step: string;
+    target_step: string;
+    missing_field: string;
+}
+export interface StepTraceDetail {
+    parent_step: string;
+    total_substeps: number;
+    successful: number;
+    failed: number;
+    pending: number;
+    skipped: number;
+    substep_ids: string[];
+}
+export interface SubstepTraceInput {
+    project_prefix: string;
+    version: string;
+    network: SubstepNetwork;
+    substeps: SubstepRecord[];
+    edges?: SubstepEdge[];
+}
+export interface SubstepTraceResult {
+    namespace: {
+        prefix: string;
+        version: string;
+    };
+    network: SubstepNetwork;
+    coherent: boolean;
+    dangling_inputs: DanglingInput[];
+    circular_refs: CircularRef[];
+    missing_outputs: MissingOutput[];
+    cross_step_breaks: CrossStepBreak[];
+    step_details: StepTraceDetail[];
+    topological_order: string[];
+    d10_check: D10CheckResult;
+}
+export interface D10CheckResult {
+    check_id: "D-10";
+    description: string;
+    status: "PASS" | "FAIL" | "WARN";
+    notes: string[];
+}
+export declare function detectDanglingInputs(substeps: SubstepRecord[], edges?: SubstepEdge[]): DanglingInput[];
+export declare function detectCircularRefs(substeps: SubstepRecord[], edges: SubstepEdge[]): CircularRef[];
+export declare function detectMissingOutputs(substeps: SubstepRecord[]): MissingOutput[];
+export declare function detectCrossStepBreaks(substeps: SubstepRecord[], edges: SubstepEdge[]): CrossStepBreak[];
+export declare function traceSubsteps(input: SubstepTraceInput): SubstepTraceResult;
+export declare class SubstepTracer {
+    private records;
+    private namespace;
+    private network;
+    constructor(prefix: string, version: string, network: SubstepNetwork);
+    record(rec: SubstepRecord): void;
+    getTrace(): SubstepRecord[];
+    updateStatus(step_id: string, status: SubstepStatus, output?: Record<string, unknown>, failure_reason?: string): void;
+    getDAG(): SubstepDAG;
+    checkCoherence(): SubstepTraceResult;
+    toJSON(): {
+        namespace: {
+            prefix: string;
+            version: string;
+        };
+        network: SubstepNetwork;
+        substeps: SubstepRecord[];
+    };
+}