@wowok/agent-mcp 2.3.13 → 2.3.16

package/dist/project/graph.js

@@ -0,0 +1,314 @@
+export class ProjectGraph {
+    nodes = new Map();
+    edges = [];
+    outEdges = new Map();
+    inEdges = new Map();
+    cycles = [];
+    updatedAt = Date.now();
+    upsertNode(node) {
+        const existing = this.nodes.get(node.id);
+        if (existing) {
+            this.nodes.set(node.id, {
+                ...existing,
+                ...node,
+                project: node.project ?? existing.project,
+                type: node.type ?? existing.type,
+                address: node.address ?? existing.address,
+            });
+            return this.nodes.get(node.id);
+        }
+        this.nodes.set(node.id, { ...node });
+        return node;
+    }
+    addEdge(from, to, kind) {
+        if (from === to)
+            return;
+        if (!this.nodes.has(from))
+            this.upsertNode({ id: from });
+        if (!this.nodes.has(to))
+            this.upsertNode({ id: to });
+        const dup = this.edges.some((e) => e.from === from && e.to === to && e.kind === kind);
+        if (dup)
+            return;
+        const idx = this.edges.length;
+        this.edges.push({ from, to, kind });
+        if (!this.outEdges.has(from))
+            this.outEdges.set(from, new Set());
+        this.outEdges.get(from).add(idx);
+        if (!this.inEdges.has(to))
+            this.inEdges.set(to, new Set());
+        this.inEdges.get(to).add(idx);
+        this.updatedAt = Date.now();
+    }
+    removeNode(id) {
+        if (!this.nodes.has(id))
+            return;
+        this.nodes.delete(id);
+        const outSet = this.outEdges.get(id);
+        const inSet = this.inEdges.get(id);
+        const indicesToRemove = new Set([
+            ...(outSet ?? []),
+            ...(inSet ?? []),
+        ]);
+        const newEdges = [];
+        const indexMap = new Map();
+        for (let i = 0; i < this.edges.length; i++) {
+            if (indicesToRemove.has(i))
+                continue;
+            indexMap.set(i, newEdges.length);
+            newEdges.push(this.edges[i]);
+        }
+        this.edges = newEdges;
+        this.outEdges.clear();
+        this.inEdges.clear();
+        for (let i = 0; i < this.edges.length; i++) {
+            const e = this.edges[i];
+            if (!this.outEdges.has(e.from))
+                this.outEdges.set(e.from, new Set());
+            this.outEdges.get(e.from).add(i);
+            if (!this.inEdges.has(e.to))
+                this.inEdges.set(e.to, new Set());
+            this.inEdges.get(e.to).add(i);
+        }
+        this.updatedAt = Date.now();
+    }
+    getNode(id) {
+        return this.nodes.get(id);
+    }
+    listNodes(projectPrefix) {
+        const all = Array.from(this.nodes.values());
+        if (!projectPrefix)
+            return all;
+        return all.filter((n) => n.project === projectPrefix);
+    }
+    getDependencies(id) {
+        const idxs = this.outEdges.get(id);
+        if (!idxs)
+            return [];
+        return Array.from(idxs).map((i) => this.edges[i]);
+    }
+    getReferencedBy(id) {
+        const idxs = this.inEdges.get(id);
+        if (!idxs)
+            return [];
+        return Array.from(idxs).map((i) => this.edges[i]);
+    }
+    detectCycles() {
+        const WHITE = 0, GRAY = 1, BLACK = 2;
+        const color = new Map();
+        for (const id of this.nodes.keys())
+            color.set(id, WHITE);
+        const cycles = [];
+        const stack = [];
+        const dfs = (u) => {
+            color.set(u, GRAY);
+            stack.push(u);
+            const outIdxs = this.outEdges.get(u);
+            if (outIdxs) {
+                for (const i of outIdxs) {
+                    const v = this.edges[i].to;
+                    if (color.get(v) === GRAY) {
+                        const start = stack.indexOf(v);
+                        if (start >= 0) {
+                            cycles.push(stack.slice(start).concat(v));
+                        }
+                    }
+                    else if (color.get(v) === WHITE) {
+                        dfs(v);
+                    }
+                }
+            }
+            stack.pop();
+            color.set(u, BLACK);
+        };
+        for (const id of this.nodes.keys()) {
+            if (color.get(id) === WHITE)
+                dfs(id);
+        }
+        this.cycles = cycles;
+        return cycles;
+    }
+    findDanglingDependencies() {
+        const result = [];
+        for (const [id, node] of this.nodes) {
+            const deps = this.getDependencies(id);
+            const missing = deps
+                .map((e) => this.nodes.get(e.to))
+                .filter((n) => !!n)
+                .filter((n) => !n.address && !n.project)
+                .map((n) => n.id);
+            if (missing.length > 0) {
+                result.push({ from: id, missing: Array.from(new Set(missing)) });
+            }
+        }
+        return result;
+    }
+    snapshot() {
+        return {
+            nodes: Object.fromEntries(this.nodes),
+            edges: this.edges,
+            cycles: this.cycles,
+            version: 1,
+            updatedAt: this.updatedAt,
+        };
+    }
+    restore(snap) {
+        this.nodes.clear();
+        this.edges = [];
+        this.outEdges.clear();
+        this.inEdges.clear();
+        for (const [id, node] of Object.entries(snap.nodes)) {
+            this.nodes.set(id, { ...node });
+        }
+        for (const e of snap.edges) {
+            this.addEdge(e.from, e.to, e.kind);
+        }
+        this.cycles = snap.cycles ?? [];
+        this.updatedAt = snap.updatedAt ?? Date.now();
+    }
+    clear() {
+        this.nodes.clear();
+        this.edges = [];
+        this.outEdges.clear();
+        this.inEdges.clear();
+        this.cycles = [];
+        this.updatedAt = Date.now();
+    }
+    get nodeCount() { return this.nodes.size; }
+    get edgeCount() { return this.edges.length; }
+    getEdges() {
+        return this.edges;
+    }
+    attachDecisionContext(nodeId, ctx) {
+        if (!nodeId)
+            return undefined;
+        const node = this.nodes.get(nodeId) ?? this.upsertNode({ id: nodeId });
+        const fullCtx = {
+            id: ctx.id ?? `${nodeId}_${Date.now()}`,
+            decided_at: ctx.decided_at ?? Date.now(),
+            decider: ctx.decider,
+            industry: ctx.industry,
+            intent: ctx.intent,
+            alternatives: ctx.alternatives,
+            rationale: ctx.rationale,
+            outcome: ctx.outcome,
+        };
+        if (!node.decision_contexts)
+            node.decision_contexts = [];
+        node.decision_contexts.push(fullCtx);
+        this.updatedAt = Date.now();
+        return fullCtx;
+    }
+    getDecisionContexts(nodeId) {
+        return this.nodes.get(nodeId)?.decision_contexts ?? [];
+    }
+    queryDecisionContextsByIndustry(industry) {
+        const results = [];
+        for (const [id, node] of this.nodes) {
+            if (!node.decision_contexts)
+                continue;
+            for (const ctx of node.decision_contexts) {
+                if (ctx.industry === industry) {
+                    results.push({ node_id: id, ctx });
+                }
+            }
+        }
+        results.sort((a, b) => b.ctx.decided_at - a.ctx.decided_at);
+        return results;
+    }
+    backfillDecisionOutcome(decisionId, outcome) {
+        for (const node of this.nodes.values()) {
+            if (!node.decision_contexts)
+                continue;
+            const ctx = node.decision_contexts.find((c) => c.id === decisionId);
+            if (ctx) {
+                ctx.outcome = outcome;
+                this.updatedAt = Date.now();
+                return true;
+            }
+        }
+        return false;
+    }
+}
+export function extractReferences(operation_type, data) {
+    const refs = [];
+    if (!data || typeof data !== "object")
+        return refs;
+    const pushRef = (field, val, kind) => {
+        if (!val)
+            return;
+        if (typeof val === "string") {
+            if (val.trim())
+                refs.push({ field, target: val.trim(), kind });
+        }
+        else if (Array.isArray(val)) {
+            for (const v of val)
+                pushRef(field, v, kind);
+        }
+        else if (typeof val === "object") {
+            const name = val.name_or_address ?? val.name ?? val.address;
+            if (typeof name === "string" && name.trim()) {
+                refs.push({ field, target: name.trim(), kind });
+            }
+        }
+    };
+    if (operation_type === "service") {
+        pushRef("machine", data.machine, "machine");
+        pushRef("order_allocators", data.order_allocators, "order_allocators");
+        pushRef("arbitrations", data.arbitrations, "arbitrations");
+        pushRef("compensation_fund", data.compensation_fund, "compensation_fund");
+        pushRef("rewards", data.rewards, "rewards");
+        pushRef("buy_guard", data.buy_guard, "buy_guard");
+        pushRef("permission", data.permission, "permission");
+    }
+    if (operation_type === "order") {
+        pushRef("service", data.service, "service");
+        pushRef("progress", data.progress, "progress");
+        pushRef("arbitration", data.arbitration, "arbitration");
+    }
+    if (operation_type === "machine" && Array.isArray(data.node?.nodes)) {
+        for (const n of data.node.nodes) {
+            if (!n || typeof n !== "object")
+                continue;
+            const nodeName = n.name;
+            if (typeof nodeName !== "string")
+                continue;
+            if (Array.isArray(n.pairs)) {
+                for (const p of n.pairs) {
+                    if (p && typeof p === "object") {
+                        if (typeof p.prev === "string") {
+                            refs.push({ field: `node.${nodeName}.prev`, target: p.prev, kind: "prev" });
+                        }
+                        if (typeof p.next === "string") {
+                            refs.push({ field: `node.${nodeName}.next`, target: p.next, kind: "next" });
+                        }
+                    }
+                }
+            }
+            if (Array.isArray(n.forward)) {
+                for (const f of n.forward) {
+                    if (f && typeof f === "object" && typeof f.next === "string") {
+                        refs.push({ field: `node.${nodeName}.forward`, target: f.next, kind: "forward" });
+                    }
+                }
+            }
+        }
+    }
+    if (operation_type === "progress" && data.parent) {
+        pushRef("parent", data.parent, "parent");
+    }
+    if (data.permission)
+        pushRef("permission", data.permission, "permission");
+    if (data.guard)
+        pushRef("guard", data.guard, "guard");
+    if (data.buy_guard)
+        pushRef("buy_guard", data.buy_guard, "buy_guard");
+    return refs;
+}
+export function nodeIdOf(name, address) {
+    if (name && typeof name === "string" && name.trim())
+        return name.trim();
+    if (address && typeof address === "string" && address.trim())
+        return address.trim();
+    return undefined;
+}

package/dist/project/index.d.ts

@@ -0,0 +1,62 @@
+import { type ProjectObjectType, type ProjectRole, type IndustryMode } from "./namespace.js";
+import { ProjectGraph } from "./graph.js";
+import { type ProjectInfo, type DependencyTrace, type ReverseTrace } from "./query.js";
+export * from "./namespace.js";
+export * from "./graph.js";
+export * from "./query.js";
+export declare function isProjectServiceEnabled(): boolean;
+export declare function getGraph(): ProjectGraph;
+export declare function setGraph(g: ProjectGraph): void;
+export interface NormalizeCallInput {
+    operation_type: string;
+    data: any;
+    projectPrefix?: string;
+    role?: ProjectRole;
+    industry?: IndustryMode;
+    version?: string;
+    shareable?: boolean;
+}
+export interface NormalizeCallResult {
+    data: any;
+    warnings: string[];
+    project?: {
+        prefix: string;
+        type?: ProjectObjectType;
+        version?: string;
+    };
+}
+export declare function normalize(input: NormalizeCallInput): NormalizeCallResult;
+export declare function observe(operation_type: string, data: any, result?: any): void;
+export declare function queryProjects(): Promise<ProjectInfo[]>;
+export declare function queryProjectObjects(prefix: string): Promise<{
+    name?: string;
+    address?: string;
+    type?: string;
+}[]>;
+export declare function queryShareableObjects(): Promise<{
+    name?: string;
+    address?: string;
+    type?: string;
+    project?: string;
+}[]>;
+export declare function queryDependencies(objectId: string): DependencyTrace;
+export declare function queryReferencedBy(objectId: string): ReverseTrace;
+export declare function queryPrePublishCheck(serviceId: string): string[];
+export declare function queryCrossProjectReferences(): {
+    edge: import("./graph.js").GraphEdge;
+    fromProject?: string;
+    toProject?: string;
+}[];
+export declare function queryGraphStats(): {
+    nodeCount: number;
+    edgeCount: number;
+    cycles: string[][];
+    dangling: {
+        from: string;
+        missing: string[];
+    }[];
+};
+export declare function saveGraph(): string;
+export declare function loadGraph(): boolean;
+export declare function hasPersistedGraph(): boolean;
+export declare const PROJECT_SERVICE_VERSION = 1;

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;