@wowok/agent-mcp 2.3.14 → 2.3.18

package/dist/project/index.js

@@ -0,0 +1,167 @@
+import { normalizeForProject, extractProjectPrefix, TAG_PREFIX, } from "./namespace.js";
+import { ProjectGraph, extractReferences, nodeIdOf, } from "./graph.js";
+import { listProjects, listProjectObjects, listShareableObjects, traceDependencies, traceReferencedBy, prePublishCheck, findCrossProjectReferences, } from "./query.js";
+import { isEnabled as isRuntimeEnabled } from "../config/index.js";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+export * from "./namespace.js";
+export * from "./graph.js";
+export * from "./query.js";
+export function isProjectServiceEnabled() {
+    return isRuntimeEnabled("project_service");
+}
+let GRAPH_INSTANCE = null;
+let GRAPH_HYDRATED = false;
+function isAutoHydrateEnabled() {
+    const v = process.env.WOWOK_PROJECT_SERVICE_HYDRATE;
+    return v === "1" || v === "true";
+}
+export function getGraph() {
+    if (!GRAPH_INSTANCE) {
+        GRAPH_INSTANCE = new ProjectGraph();
+        if (isAutoHydrateEnabled() && !GRAPH_HYDRATED) {
+            GRAPH_HYDRATED = true;
+            try {
+                loadGraph();
+            }
+            catch {
+            }
+        }
+    }
+    return GRAPH_INSTANCE;
+}
+export function setGraph(g) {
+    GRAPH_INSTANCE = g;
+}
+export function normalize(input) {
+    if (!isProjectServiceEnabled()) {
+        return { data: input.data, warnings: [] };
+    }
+    return normalizeForProject({
+        operation_type: input.operation_type,
+        data: input.data,
+        projectPrefix: input.projectPrefix,
+        role: input.role,
+        industry: input.industry,
+        version: input.version,
+        shareable: input.shareable,
+    });
+}
+export function observe(operation_type, data, result) {
+    if (!isProjectServiceEnabled())
+        return;
+    try {
+        const graph = getGraph();
+        const namedNew = data?.namedNew ?? data?.object;
+        const name = namedNew?.name;
+        const address = extractAddressFromResult(result);
+        const nodeId = nodeIdOf(name, address);
+        if (!nodeId)
+            return;
+        const tags = namedNew?.tags;
+        const project = extractProjectPrefix(tags);
+        const typeTag = tags?.find((t) => t.startsWith(TAG_PREFIX.type));
+        const type = typeTag?.slice(TAG_PREFIX.type.length);
+        const node = { id: nodeId, project, type, address };
+        graph.upsertNode(node);
+        const refs = extractReferences(operation_type, data);
+        for (const r of refs) {
+            graph.addEdge(nodeId, r.target, r.kind);
+        }
+        if (isRuntimeEnabled("graph_persist")) {
+            try {
+                saveGraph();
+            }
+            catch {
+            }
+        }
+    }
+    catch {
+    }
+}
+function extractAddressFromResult(result) {
+    if (!result || typeof result !== "object")
+        return undefined;
+    const candidate = result?.object_id ??
+        result?.objectId ??
+        result?.effects?.created?.[0]?.reference?.objectId ??
+        result?.objectRef?.objectId ??
+        result?.data?.objectId;
+    if (typeof candidate === "string" && candidate.startsWith("0x"))
+        return candidate;
+    const inner = result.result ?? result.data;
+    if (inner && typeof inner === "object") {
+        const c2 = inner.object_id ??
+            inner.objectId ??
+            inner.effects?.created?.[0]?.reference?.objectId ??
+            inner.objectRef?.objectId;
+        if (typeof c2 === "string" && c2.startsWith("0x"))
+            return c2;
+    }
+    return undefined;
+}
+export async function queryProjects() {
+    return listProjects();
+}
+export async function queryProjectObjects(prefix) {
+    return listProjectObjects(prefix);
+}
+export async function queryShareableObjects() {
+    return listShareableObjects();
+}
+export function queryDependencies(objectId) {
+    return traceDependencies(getGraph(), objectId);
+}
+export function queryReferencedBy(objectId) {
+    return traceReferencedBy(getGraph(), objectId);
+}
+export function queryPrePublishCheck(serviceId) {
+    return prePublishCheck(getGraph(), serviceId);
+}
+export function queryCrossProjectReferences() {
+    return findCrossProjectReferences(getGraph());
+}
+export function queryGraphStats() {
+    const g = getGraph();
+    return {
+        nodeCount: g.nodeCount,
+        edgeCount: g.edgeCount,
+        cycles: g.detectCycles(),
+        dangling: g.findDanglingDependencies(),
+    };
+}
+function graphFilePath() {
+    const dir = process.env.WOWOK_CONFIG_DIR
+        ? process.env.WOWOK_CONFIG_DIR
+        : join(homedir(), ".wowok");
+    return join(dir, "project-graph.json");
+}
+export function saveGraph() {
+    const path = graphFilePath();
+    const dir = dirname(path);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    const snap = getGraph().snapshot();
+    writeFileSync(path, JSON.stringify(snap, null, 2), "utf-8");
+    return path;
+}
+export function loadGraph() {
+    const path = graphFilePath();
+    if (!existsSync(path))
+        return false;
+    try {
+        const raw = readFileSync(path, "utf-8");
+        const snap = JSON.parse(raw);
+        if (snap && snap.nodes && snap.edges) {
+            getGraph().restore(snap);
+            return true;
+        }
+    }
+    catch { }
+    return false;
+}
+export function hasPersistedGraph() {
+    return existsSync(graphFilePath());
+}
+export const PROJECT_SERVICE_VERSION = 1;

package/dist/project/namespace.d.ts

@@ -0,0 +1,62 @@
+export type ProjectObjectType = "service" | "machine" | "guard" | "permission" | "reward" | "arb" | "progress" | "treasury" | "demand" | "repository" | "contact" | "order" | "allocation" | "personal" | "payment" | "proof";
+export type ProjectRole = "workflow" | "trust" | "revenue" | "acceptance" | "identity" | "communication" | "marketing" | "governance";
+export type IndustryMode = "freelance" | "rental" | "education" | "travel" | "subscription" | "general";
+export declare const TAG_PREFIX: {
+    readonly project: "project:";
+    readonly type: "type:";
+    readonly role: "role:";
+    readonly industry: "industry:";
+    readonly version: "version:";
+    readonly shareable: "shareable:";
+    readonly archived: "archived:";
+};
+export declare const NAMESPACE_CONSTRAINTS: {
+    readonly projectPrefixMin: 3;
+    readonly projectPrefixMax: 16;
+    readonly purposeMin: 1;
+    readonly purposeMax: 32;
+    readonly versionPattern: RegExp;
+};
+export interface NameValidation {
+    valid: boolean;
+    reason?: string;
+    parsed?: {
+        projectPrefix: string;
+        type: ProjectObjectType;
+        purpose: string;
+        version?: string;
+    };
+}
+export declare function validateProjectName(name: string): NameValidation;
+export declare function objectTypeFromOperation(operation_type: string): ProjectObjectType | undefined;
+export interface TagInjectionOptions {
+    projectPrefix?: string;
+    type?: ProjectObjectType;
+    role?: ProjectRole;
+    industry?: IndustryMode;
+    version?: string;
+    shareable?: boolean;
+    existingTags?: string[];
+}
+export declare function buildProjectTags(opts: TagInjectionOptions): string[];
+export declare function extractProjectPrefix(tags: string[] | undefined): string | undefined;
+export interface NormalizeResult {
+    data: any;
+    warnings: string[];
+    project?: {
+        prefix: string;
+        type?: ProjectObjectType;
+        version?: string;
+    };
+}
+export interface NormalizeInput {
+    operation_type: string;
+    data: any;
+    projectPrefix?: string;
+    role?: ProjectRole;
+    industry?: IndustryMode;
+    version?: string;
+    shareable?: boolean;
+}
+export declare function normalizeForProject(input: NormalizeInput): NormalizeResult;
+export declare const NAMESPACE_VERSION = 1;

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,17 @@
+import type { CallEnv } from "../schema/call/base.js";
+import { type ConfirmLevel, type OperationPreview } from "../knowledge/safety-rules.js";
+export declare function isConfirmGateEnabled(): boolean;
+export type FailMode = "open" | "closed";
+export type ConfirmResult = {
+    pass: true;
+} | {
+    pass: false;
+    level: ConfirmLevel;
+    preview: OperationPreview;
+    rule_id: string;
+};
+export declare function getFailMode(level: ConfirmLevel): FailMode;
+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,88 @@
+import { CONFIRMATION_RULES, } from "../knowledge/safety-rules.js";
+import { isEnabled as isRuntimeEnabled } from "../config/index.js";
+export function isConfirmGateEnabled() {
+    return isRuntimeEnabled("confirm_gate");
+}
+const internalErrorCounts = {};
+function logInternalError(context, error) {
+    const key = context;
+    internalErrorCounts[key] = (internalErrorCounts[key] ?? 0) + 1;
+    const count = internalErrorCounts[key];
+    console.warn(`[ConfirmGate] internal_error context="${context}" count=${count} error=${error instanceof Error ? error.message : String(error)}`);
+}
+export function getFailMode(level) {
+    switch (level) {
+        case "irreversible":
+        case "publish":
+        case "amount":
+            return "closed";
+        case "standard":
+        case "none":
+        default:
+            return "open";
+    }
+}
+function buildInternalErrorResult() {
+    return {
+        pass: false,
+        level: "irreversible",
+        preview: {
+            level: "irreversible",
+            operation: "unknown",
+            irreversible: true,
+        },
+        rule_id: "internal_error",
+    };
+}
+export function confirmGate(operation_type, data, env, userIntentPhrases) {
+    if (!isConfirmGateEnabled())
+        return { pass: true };
+    if (env?.confirmed === true)
+        return { pass: true };
+    let matched;
+    let ruleSearchError = null;
+    try {
+        matched = CONFIRMATION_RULES.find((r) => {
+            try {
+                return r.when(operation_type, data, env);
+            }
+            catch (e) {
+                logInternalError(`rule_when:${r.id}`, e);
+                if (getFailMode(r.level) === "closed") {
+                    throw e;
+                }
+                return false;
+            }
+        });
+    }
+    catch (e) {
+        ruleSearchError = e;
+    }
+    if (ruleSearchError) {
+        logInternalError("rule_search", ruleSearchError);
+        return buildInternalErrorResult();
+    }
+    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 (e) {
+        logInternalError(`rule_preview:${matched.id}`, e);
+        if (getFailMode(matched.level) === "closed") {
+            return buildInternalErrorResult();
+        }
+        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;