@wowok/agent-mcp 2.3.13 → 2.3.16

package/dist/project/namespace.js

@@ -0,0 +1,181 @@
+export const TAG_PREFIX = {
+    project: "project:",
+    type: "type:",
+    role: "role:",
+    industry: "industry:",
+    version: "version:",
+    shareable: "shareable:",
+    archived: "archived:",
+};
+export const NAMESPACE_CONSTRAINTS = {
+    projectPrefixMin: 3,
+    projectPrefixMax: 16,
+    purposeMin: 1,
+    purposeMax: 32,
+    versionPattern: /^v\d+$/,
+};
+export function validateProjectName(name) {
+    if (!name || typeof name !== "string") {
+        return { valid: false, reason: "name is empty" };
+    }
+    if (name.startsWith("0x")) {
+        return { valid: false, reason: "name must not start with '0x'" };
+    }
+    if (/^0x[0-9a-fA-F]{64}$/.test(name)) {
+        return { valid: false, reason: "name is an on-chain address, not a project name" };
+    }
+    const parts = name.split("_");
+    if (parts.length < 3) {
+        return {
+            valid: false,
+            reason: "name does not match `<prefix>_<type>_<purpose>[_v<version>]`",
+        };
+    }
+    const projectPrefix = parts[0];
+    const typeStr = parts[1];
+    let version;
+    let purpose;
+    const last = parts[parts.length - 1];
+    if (NAMESPACE_CONSTRAINTS.versionPattern.test(last)) {
+        version = last;
+        purpose = parts.slice(2, -1).join("_") || parts[2];
+    }
+    else {
+        purpose = parts.slice(2).join("_");
+    }
+    if (projectPrefix.length < NAMESPACE_CONSTRAINTS.projectPrefixMin) {
+        return { valid: false, reason: `projectPrefix too short (min ${NAMESPACE_CONSTRAINTS.projectPrefixMin})` };
+    }
+    if (projectPrefix.length > NAMESPACE_CONSTRAINTS.projectPrefixMax) {
+        return { valid: false, reason: `projectPrefix too long (max ${NAMESPACE_CONSTRAINTS.projectPrefixMax})` };
+    }
+    if (!/^[a-z][a-z0-9]*$/.test(projectPrefix)) {
+        return { valid: false, reason: "projectPrefix must be lowercase alphanumeric (start with a letter)" };
+    }
+    if (!isProjectObjectType(typeStr)) {
+        return { valid: false, reason: `unknown object type '${typeStr}'` };
+    }
+    if (!purpose || purpose.length < NAMESPACE_CONSTRAINTS.purposeMin) {
+        return { valid: false, reason: "purpose is empty" };
+    }
+    if (purpose.length > NAMESPACE_CONSTRAINTS.purposeMax) {
+        return { valid: false, reason: `purpose too long (max ${NAMESPACE_CONSTRAINTS.purposeMax})` };
+    }
+    if (!/^[a-zA-Z][a-zA-Z0-9]*$/.test(purpose)) {
+        return { valid: false, reason: "purpose must be alphanumeric (start with a letter)" };
+    }
+    return {
+        valid: true,
+        parsed: { projectPrefix, type: typeStr, purpose, version },
+    };
+}
+function isProjectObjectType(s) {
+    return [
+        "service", "machine", "guard", "permission", "reward", "arb",
+        "progress", "treasury", "demand", "repository", "contact", "order",
+        "allocation", "personal", "payment", "proof",
+    ].includes(s);
+}
+export function objectTypeFromOperation(operation_type) {
+    const direct = {
+        service: "service",
+        machine: "machine",
+        guard: "guard",
+        permission: "permission",
+        reward: "reward",
+        arbitration: "arb",
+        progress: "progress",
+        treasury: "treasury",
+        demand: "demand",
+        repository: "repository",
+        contact: "contact",
+        order: "order",
+        allocation: "allocation",
+        personal: "personal",
+        payment: "payment",
+        proof: "proof",
+    };
+    return direct[operation_type];
+}
+export function buildProjectTags(opts) {
+    const tags = new Set(opts.existingTags ?? []);
+    if (opts.projectPrefix) {
+        tags.add(`${TAG_PREFIX.project}${opts.projectPrefix}`);
+    }
+    if (opts.type) {
+        tags.add(`${TAG_PREFIX.type}${opts.type}`);
+    }
+    if (opts.role) {
+        tags.add(`${TAG_PREFIX.role}${opts.role}`);
+    }
+    if (opts.industry) {
+        tags.add(`${TAG_PREFIX.industry}${opts.industry}`);
+    }
+    if (opts.version) {
+        tags.add(`${TAG_PREFIX.version}${opts.version}`);
+    }
+    if (opts.shareable) {
+        tags.add(`${TAG_PREFIX.shareable}true`);
+    }
+    return Array.from(tags);
+}
+export function extractProjectPrefix(tags) {
+    if (!tags)
+        return undefined;
+    for (const t of tags) {
+        if (t.startsWith(TAG_PREFIX.project)) {
+            return t.slice(TAG_PREFIX.project.length);
+        }
+    }
+    return undefined;
+}
+export function normalizeForProject(input) {
+    const warnings = [];
+    const data = input.data;
+    if (!data || typeof data !== "object") {
+        return { data, warnings };
+    }
+    const namedNew = data.namedNew ?? data.object;
+    if (!namedNew || typeof namedNew !== "object") {
+        return { data, warnings };
+    }
+    const name = namedNew.name;
+    const inferredType = objectTypeFromOperation(input.operation_type);
+    let prefix = input.projectPrefix;
+    let version = input.version;
+    let nameValidation;
+    if (name) {
+        nameValidation = validateProjectName(name);
+        if (nameValidation.valid && nameValidation.parsed) {
+            prefix = prefix ?? nameValidation.parsed.projectPrefix;
+            version = version ?? nameValidation.parsed.version;
+        }
+        else if (nameValidation.reason && !nameValidation.reason.includes("address")) {
+            warnings.push(`Object name '${name}' does not follow the project naming convention ` +
+                `'<prefix>_<type>_<purpose>[_v<version>]': ${nameValidation.reason}. ` +
+                `Consider renaming for better project organization.`);
+        }
+    }
+    if (!prefix) {
+        return { data, warnings };
+    }
+    const existingTags = Array.isArray(namedNew.tags) ? namedNew.tags : [];
+    const projectTags = buildProjectTags({
+        projectPrefix: prefix,
+        type: inferredType,
+        role: input.role,
+        industry: input.industry,
+        version,
+        shareable: input.shareable,
+        existingTags,
+    });
+    if (projectTags.length > existingTags.length) {
+        namedNew.tags = projectTags;
+    }
+    return {
+        data,
+        warnings,
+        project: { prefix, type: inferredType, version },
+    };
+}
+export const NAMESPACE_VERSION = 1;

package/dist/project/query.d.ts

@@ -0,0 +1,40 @@
+import type { ProjectGraph, GraphEdge } from "./graph.js";
+export interface ProjectInfo {
+    prefix: string;
+    objectCount: number;
+    types: string[];
+    objects: Array<{
+        name?: string;
+        address?: string;
+        type?: string;
+    }>;
+}
+export interface DependencyTrace {
+    object: string;
+    directDependencies: GraphEdge[];
+    transitive: Array<{
+        object: string;
+        via: string[];
+    }>;
+    dangling: string[];
+}
+export interface ReverseTrace {
+    object: string;
+    referencedBy: GraphEdge[];
+}
+export declare function listProjects(): Promise<ProjectInfo[]>;
+export declare function listProjectObjects(prefix: string): Promise<ProjectInfo["objects"]>;
+export declare function listShareableObjects(): Promise<Array<{
+    name?: string;
+    address?: string;
+    type?: string;
+    project?: string;
+}>>;
+export declare function traceDependencies(graph: ProjectGraph, objectId: string): DependencyTrace;
+export declare function traceReferencedBy(graph: ProjectGraph, objectId: string): ReverseTrace;
+export declare function prePublishCheck(graph: ProjectGraph, serviceId: string): string[];
+export declare function findCrossProjectReferences(graph: ProjectGraph): Array<{
+    edge: GraphEdge;
+    fromProject?: string;
+    toProject?: string;
+}>;

package/dist/project/query.js

@@ -0,0 +1,110 @@
+import { LocalMark } from "@wowok/wowok";
+import { extractProjectPrefix, 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)
+            continue;
+        if (!byProject.has(prefix)) {
+            byProject.set(prefix, { prefix, objectCount: 0, types: [], objects: [] });
+        }
+        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 });
+    }
+    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 typeTag = m.tags?.find((t) => t.startsWith(TAG_PREFIX.type));
+        return {
+            name: m.name,
+            address: m.address,
+            type: typeTag?.slice(TAG_PREFIX.type.length),
+        };
+    });
+}
+export async function listShareableObjects() {
+    const marks = await LocalMark.Instance().list({ tags: [`${TAG_PREFIX.shareable}true`] });
+    return marks.map((m) => {
+        const typeTag = m.tags?.find((t) => t.startsWith(TAG_PREFIX.type));
+        const projectTag = m.tags?.find((t) => t.startsWith(TAG_PREFIX.project));
+        return {
+            name: m.name,
+            address: m.address,
+            type: typeTag?.slice(TAG_PREFIX.type.length),
+            project: projectTag?.slice(TAG_PREFIX.project.length),
+        };
+    });
+}
+export function traceDependencies(graph, objectId) {
+    const directDependencies = graph.getDependencies(objectId);
+    const visited = new Set([objectId]);
+    const transitive = [];
+    const queue = directDependencies.map((e) => ({ id: e.to, via: [e.from, e.to] }));
+    const dangling = new Set();
+    while (queue.length > 0) {
+        const { id, via } = queue.shift();
+        if (visited.has(id))
+            continue;
+        visited.add(id);
+        const node = graph.getNode(id);
+        if (!node || (!node.address && !node.project)) {
+            dangling.add(id);
+        }
+        transitive.push({ object: id, via });
+        const nextEdges = graph.getDependencies(id);
+        for (const e of nextEdges) {
+            if (!visited.has(e.to)) {
+                queue.push({ id: e.to, via: [...via, e.to] });
+            }
+        }
+    }
+    return {
+        object: objectId,
+        directDependencies,
+        transitive,
+        dangling: Array.from(dangling),
+    };
+}
+export function traceReferencedBy(graph, objectId) {
+    return {
+        object: objectId,
+        referencedBy: graph.getReferencedBy(objectId),
+    };
+}
+export function prePublishCheck(graph, serviceId) {
+    const warnings = [];
+    const trace = traceDependencies(graph, serviceId);
+    if (trace.dangling.length > 0) {
+        warnings.push(`Service '${serviceId}' references objects not yet created: ${trace.dangling.join(", ")}. ` +
+            `Publishing will lock 'machine' and 'order_allocators' — ensure these are finalized first.`);
+    }
+    const cycles = graph.detectCycles();
+    if (cycles.length > 0) {
+        warnings.push(`Dependency graph contains ${cycles.length} cycle(s): ` +
+            cycles.map((c) => c.join(" → ")).join("; ") +
+            `. Cycles may indicate a design issue.`);
+    }
+    return warnings;
+}
+export function findCrossProjectReferences(graph) {
+    const result = [];
+    for (const edge of graph.getEdges()) {
+        const fromNode = graph.getNode(edge.from);
+        const toNode = graph.getNode(edge.to);
+        const fromProj = fromNode?.project;
+        const toProj = toNode?.project;
+        if (fromProj && toProj && fromProj !== toProj) {
+            result.push({ edge, fromProject: fromProj, toProject: toProj });
+        }
+    }
+    return result;
+}

package/dist/safety/confirm-gate.d.ts

@@ -0,0 +1,15 @@
+import type { CallEnv } from "../schema/call/base.js";
+import { type ConfirmationRule, type OperationPreview } from "../knowledge/safety-rules.js";
+export declare function isConfirmGateEnabled(): boolean;
+export type ConfirmResult = {
+    pass: true;
+} | {
+    pass: false;
+    level: ConfirmationRule["level"];
+    preview: OperationPreview;
+    rule_id: string;
+};
+export declare function confirmGate(operation_type: string, data: any, env: any, userIntentPhrases?: string[]): ConfirmResult;
+export declare function isExplicitlyConfirmed(env: CallEnv & {
+    confirmed?: boolean;
+}): boolean;

package/dist/safety/confirm-gate.js

@@ -0,0 +1,44 @@
+import { CONFIRMATION_RULES, } from "../knowledge/safety-rules.js";
+import { isEnabled as isRuntimeEnabled } from "../config/index.js";
+export function isConfirmGateEnabled() {
+    return isRuntimeEnabled("confirm_gate");
+}
+export function confirmGate(operation_type, data, env, userIntentPhrases) {
+    if (!isConfirmGateEnabled())
+        return { pass: true };
+    if (env?.confirmed === true)
+        return { pass: true };
+    let matched;
+    try {
+        matched = CONFIRMATION_RULES.find((r) => {
+            try {
+                return r.when(operation_type, data, env);
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    catch {
+        return { pass: true };
+    }
+    if (!matched)
+        return { pass: true };
+    if (matched.bypass_on_explicit_intent && userIntentPhrases && userIntentPhrases.length > 0) {
+        const lower = userIntentPhrases.map((p) => p.toLowerCase());
+        const bypass = matched.bypass_on_explicit_intent.some((p) => lower.some((u) => u.includes(p.toLowerCase())));
+        if (bypass)
+            return { pass: true };
+    }
+    let preview;
+    try {
+        preview = matched.preview(operation_type, data, env);
+    }
+    catch {
+        return { pass: true };
+    }
+    return { pass: false, level: matched.level, preview, rule_id: matched.id };
+}
+export function isExplicitlyConfirmed(env) {
+    return env?.confirmed === true;
+}

package/dist/safety/index.d.ts

@@ -0,0 +1,3 @@
+export { confirmGate, isConfirmGateEnabled, isExplicitlyConfirmed, type ConfirmResult, } from "./confirm-gate.js";
+export { renderPreview } from "./preview.js";
+export { CONFIRMATION_RULES, DEFAULT_VALUE_WARNINGS, DEFAULT_AMOUNT_THRESHOLD, getAmountThreshold, formatAmount, collectDefaultWarnings, type ConfirmLevel, type OperationPreview, type ConfirmationRule, SAFETY_RULES_VERSION, } from "../knowledge/safety-rules.js";

package/dist/safety/index.js

@@ -0,0 +1,3 @@
+export { confirmGate, isConfirmGateEnabled, isExplicitlyConfirmed, } from "./confirm-gate.js";
+export { renderPreview } from "./preview.js";
+export { CONFIRMATION_RULES, DEFAULT_VALUE_WARNINGS, DEFAULT_AMOUNT_THRESHOLD, getAmountThreshold, formatAmount, collectDefaultWarnings, SAFETY_RULES_VERSION, } from "../knowledge/safety-rules.js";

package/dist/safety/preview.d.ts

@@ -0,0 +1,2 @@
+import type { OperationPreview } from "../knowledge/safety-rules.js";
+export declare function renderPreview(p: OperationPreview): string;

package/dist/safety/preview.js

@@ -0,0 +1,36 @@
+const LEVEL_LABEL = {
+    none: "none",
+    standard: "Standard confirmation",
+    amount: "Amount confirmation",
+    publish: "Publish confirmation (irreversible lock)",
+    irreversible: "Irreversible operation confirmation",
+};
+export function renderPreview(p) {
+    const lines = [];
+    lines.push(`⚠️  Confirmation required — ${LEVEL_LABEL[p.level]}`);
+    lines.push(`  Operation: ${p.operation}`);
+    if (p.object)
+        lines.push(`  Object: ${p.object}`);
+    if (p.network)
+        lines.push(`  Network: ${p.network}`);
+    if (p.account !== undefined)
+        lines.push(`  Account: ${p.account === "" ? "(default)" : p.account}`);
+    if (p.amount) {
+        lines.push(`  Amount: ${p.amount.human_readable} (${p.amount.value} smallest unit)` +
+            (p.amount.recipient ? ` → ${p.amount.recipient}` : ""));
+    }
+    if (p.immutable_after && p.immutable_after.length > 0) {
+        lines.push(`  Fields becoming immutable: ${p.immutable_after.join(", ")}`);
+    }
+    if (p.warnings && p.warnings.length > 0) {
+        lines.push("  Warnings:");
+        for (const w of p.warnings)
+            lines.push(`    - ${w}`);
+    }
+    if (p.irreversible) {
+        lines.push("  ⛔ This operation is IRREVERSIBLE. It cannot be undone.");
+    }
+    lines.push("");
+    lines.push("Confirm by re-calling with env.confirmed=true, or modify/cancel.");
+    return lines.join("\n");
+}