@wowok/agent-mcp 2.5.4 → 2.6.0

package/dist/project/handlers.js

@@ -0,0 +1,567 @@
+import { LocalProject, LocalMark, query_objects, } from "@wowok/wowok";
+import { GraphBuilder } from "./graph-builder.js";
+import { SemanticAssembler } from "./semantic-assembler.js";
+import { runEvaluation, compareProjects, } from "./evaluation.js";
+const localProject = LocalProject.Instance();
+function requireField(value, name) {
+    if (value === undefined || value === null) {
+        throw new Error(`'${name}' is required for this action`);
+    }
+    return value;
+}
+async function resolveProjectId(v) {
+    if (v.project_id)
+        return v.project_id;
+    if (v.project) {
+        const p = await localProject.getProjectByPrefix(v.project);
+        if (!p)
+            throw new Error(`Project not found by prefix: ${v.project}`);
+        return p.id;
+    }
+    throw new Error("Either 'project_id' or 'project' (prefix) is required for this action");
+}
+async function resolveObjectAddress(v) {
+    if (v.object_address)
+        return v.object_address;
+    if (v.object_name_add) {
+        const mark = await LocalMark.Instance().get(v.object_name_add);
+        if (mark?.address)
+            return mark.address;
+        throw new Error(`LocalMark name not found: ${v.object_name_add}`);
+    }
+    throw new Error("Either 'object_address' or 'object_name_add' is required for add_object");
+}
+export async function handleListProjects(v) {
+    const filter = {};
+    if (v.filter_status)
+        filter.status = v.filter_status;
+    if (v.filter_perspective)
+        filter.perspective = v.filter_perspective;
+    if (v.filter_network)
+        filter.network = v.filter_network;
+    const projects = await localProject.listProjects(Object.keys(filter).length > 0 ? filter : undefined);
+    const items = await Promise.all(projects.map(async (p) => {
+        const [objs, evals] = await Promise.all([
+            localProject.listObjects(p.id),
+            localProject.listEvaluations(p.id),
+        ]);
+        const types = new Set();
+        for (const o of objs) {
+            if (o.objectType)
+                types.add(o.objectType);
+        }
+        if (p.status === "draft" && objs.length > 0) {
+            const updated = await localProject.updateProject(p.id, { status: "active" });
+            if (updated) {
+                return {
+                    ...updated,
+                    objectCount: objs.length,
+                    evaluationCount: evals.length,
+                    objectTypes: Array.from(types),
+                };
+            }
+        }
+        return {
+            ...p,
+            objectCount: objs.length,
+            evaluationCount: evals.length,
+            objectTypes: Array.from(types),
+        };
+    }));
+    return {
+        action: "list_projects",
+        items,
+        total: items.length,
+    };
+}
+export async function handleCreateProject(v) {
+    const prefix = requireField(v.project, "project (prefix)");
+    const name = requireField(v.project_name, "project_name");
+    const existing = await localProject.getProjectByPrefix(prefix);
+    if (existing) {
+        throw new Error(`Project prefix '${prefix}' already exists (project: '${existing.name}', id: '${existing.id}'). ` +
+            `Use a different prefix or update the existing project.`);
+    }
+    const create = {
+        prefix,
+        name,
+        description: v.project_description,
+        industry: v.project_industry,
+        perspective: v.project_perspective ?? "producer",
+        labels: v.project_labels,
+        serviceAddress: v.service_address,
+        network: v.project_network ?? "testnet",
+    };
+    const project = await localProject.createProject(create);
+    return { action: "create_project", project };
+}
+export async function handleCreateProjectFromOnchain(v) {
+    const serviceAddress = requireField(v.service_address, "service_address");
+    const network = (v.project_network ?? "testnet");
+    let prefix = v.project ?? `svc_${serviceAddress.slice(2, 8)}`;
+    const name = v.project_name ?? `Consumer Project ${serviceAddress.slice(2, 8)}`;
+    const existing = await localProject.getProjectByPrefix(prefix);
+    if (existing) {
+        if (v.project) {
+            throw new Error(`Project prefix '${prefix}' already exists (project: '${existing.name}', id: '${existing.id}'). ` +
+                `Use a different prefix.`);
+        }
+        let suffix = 2;
+        while (await localProject.getProjectByPrefix(`${prefix}_${suffix}`)) {
+            suffix++;
+        }
+        prefix = `${prefix}_${suffix}`;
+    }
+    const project = await localProject.createProject({
+        prefix,
+        name,
+        description: v.project_description ?? `Auto-discovered from Service ${serviceAddress}`,
+        industry: v.project_industry,
+        perspective: "consumer",
+        labels: v.project_labels,
+        serviceAddress,
+        network: network,
+    });
+    const builder = new GraphBuilder({
+        maxDepth: v.max_depth ?? 3,
+        enableRegistrar: v.enable_registrar ?? true,
+        enablePotential: v.enable_potential ?? false,
+        projectId: project.id,
+        network: network,
+    });
+    const graphResult = await builder.buildRelationshipGraph(serviceAddress);
+    const objects = [];
+    for (const node of graphResult.graph.nodes) {
+        const isCore = node.address === serviceAddress;
+        const obj = await localProject.addObject(project.id, {
+            objectAddress: node.address,
+            objectType: node.objectType ?? undefined,
+            objectName: node.objectName ?? undefined,
+            role: (isCore ? "core" : "dependency"),
+        });
+        objects.push(obj);
+    }
+    const updatedProject = await localProject.updateProject(project.id, { status: "active" });
+    return {
+        action: "create_project_from_onchain",
+        project: updatedProject ?? project,
+        objects,
+        graphEdgeCount: graphResult.graph.edges.length,
+    };
+}
+export async function handleUpdateProject(v) {
+    const id = await resolveProjectId(v);
+    const update = {
+        name: v.project_name,
+        description: v.project_description,
+        industry: v.project_industry,
+        perspective: v.project_perspective,
+        status: v.project_status,
+        labels: v.project_labels,
+        serviceAddress: v.service_address,
+    };
+    const project = await localProject.updateProject(id, update);
+    return { action: "update_project", project };
+}
+export async function handleGetProjectDetail(v) {
+    const id = await resolveProjectId(v);
+    const project = await localProject.getProject(id);
+    if (!project)
+        throw new Error(`Project not found: ${id}`);
+    const objects = await localProject.listObjects(id);
+    const edges = await localProject.getGraph(id);
+    const evaluations = await localProject.listEvaluations(id);
+    const versions = await localProject.listVersions(id);
+    let effectiveProject = project;
+    if (project.status === "draft" && objects.length > 0) {
+        const updated = await localProject.updateProject(id, { status: "active" });
+        if (updated)
+            effectiveProject = updated;
+    }
+    const needsNameFix = objects.some(o => !o.objectName);
+    const needsRoleFix = objects.some(o => o.role === "reference");
+    if (needsNameFix || needsRoleFix) {
+        const allMarks = await LocalMark.Instance().list(null);
+        const addressToName = new Map();
+        for (const m of allMarks) {
+            if (m.name && m.address) {
+                addressToName.set(m.address.toLowerCase(), m.name);
+            }
+        }
+        for (const obj of objects) {
+            const updates = {};
+            if (!obj.objectName) {
+                const name = addressToName.get(obj.objectAddress.toLowerCase());
+                if (name) {
+                    updates.objectName = name;
+                    obj.objectName = name;
+                }
+            }
+            if (obj.role === "reference" && obj.objectType) {
+                const t = obj.objectType;
+                if (t.includes("service::Service")) {
+                    updates.role = "core";
+                    obj.role = "core";
+                }
+                else if (t.includes("permission::Permission") ||
+                    t.includes("machine::Machine") ||
+                    t.includes("guard::Guard") ||
+                    t.includes("reward::Reward") ||
+                    t.includes("treasury::Treasury") ||
+                    t.includes("allocation::Allocation") ||
+                    t.includes("progress::Progress") ||
+                    t.includes("arbitration::Arbitration") ||
+                    t.includes("demand::Demand") ||
+                    t.includes("order::Order") ||
+                    t.includes("repository::Repository")) {
+                    updates.role = "dependency";
+                    obj.role = "dependency";
+                }
+            }
+            if (effectiveProject.serviceAddress &&
+                obj.objectAddress === effectiveProject.serviceAddress &&
+                obj.role !== "core") {
+                updates.role = "core";
+                obj.role = "core";
+            }
+            if (Object.keys(updates).length > 0) {
+                await localProject.updateObject(obj.id, updates).catch(() => { });
+            }
+        }
+    }
+    return {
+        action: "get_project_detail",
+        project: effectiveProject,
+        objects,
+        graphEdgeCount: edges.length,
+        evaluations: evaluations.map(e => ({
+            id: e.id,
+            evalType: e.evalType,
+            score: e.score,
+            summary: e.summary,
+            details: e.details,
+            evaluatedAt: e.evaluatedAt,
+        })),
+        versions: versions.map(v => ({
+            version: v.version,
+            description: v.description,
+            createdAt: v.createdAt,
+        })),
+    };
+}
+export async function handleAddObject(v) {
+    const projectId = await resolveProjectId(v);
+    const objectAddress = await resolveObjectAddress(v);
+    let objectName = v.object_name_add;
+    let role = v.object_role;
+    if (!objectName) {
+        const marks = await LocalMark.Instance().list({ address: objectAddress });
+        if (marks.length > 0 && marks[0].name) {
+            objectName = marks[0].name;
+        }
+    }
+    if (!role) {
+        const objType = v.object_type_add ?? "";
+        if (objType.includes("service::Service")) {
+            role = "core";
+        }
+        else if (objType.includes("::") && (objType.includes("permission::") ||
+            objType.includes("machine::") ||
+            objType.includes("guard::") ||
+            objType.includes("reward::") ||
+            objType.includes("treasury::") ||
+            objType.includes("allocation::") ||
+            objType.includes("progress::") ||
+            objType.includes("arbitration::") ||
+            objType.includes("demand::") ||
+            objType.includes("order::") ||
+            objType.includes("repository::"))) {
+            role = "dependency";
+        }
+        else {
+            role = "reference";
+        }
+    }
+    const obj = await localProject.addObject(projectId, {
+        objectAddress,
+        objectType: v.object_type_add,
+        objectName,
+        role,
+        tags: v.object_tags_add,
+    });
+    const project = await localProject.getProject(projectId);
+    if (project && project.status === "draft") {
+        await localProject.updateProject(projectId, { status: "active" });
+    }
+    return { action: "add_object", object: obj };
+}
+export async function handleRemoveObject(v) {
+    const objectId = requireField(v.object_id_remove, "object_id_remove");
+    await localProject.removeObject(objectId);
+    return { action: "remove_object", removed: true };
+}
+export async function handleUpdateObject(v) {
+    const objectId = requireField(v.object_id_update, "object_id_update");
+    const updates = {};
+    if (v.object_name_update !== undefined)
+        updates.objectName = v.object_name_update;
+    if (v.object_type_update !== undefined)
+        updates.objectType = v.object_type_update;
+    if (v.object_role_update !== undefined)
+        updates.role = v.object_role_update;
+    if (v.object_tags_update !== undefined)
+        updates.tags = v.object_tags_update;
+    const obj = await localProject.updateObject(objectId, updates);
+    return { action: "update_object", object: obj };
+}
+export async function handleCreateVersion(v) {
+    const projectId = await resolveProjectId(v);
+    const version = requireField(v.version, "version");
+    const project = await localProject.getProject(projectId);
+    if (!project)
+        throw new Error(`Project not found: ${projectId}`);
+    const created = await localProject.createVersion(projectId, version, v.version_description);
+    return {
+        action: "create_version",
+        version: {
+            version: created.version,
+            description: created.description,
+            createdAt: created.createdAt,
+        },
+    };
+}
+export async function handleBuildGraph(v) {
+    const projectId = await resolveProjectId(v);
+    const project = await localProject.getProject(projectId);
+    if (!project)
+        throw new Error(`Project not found: ${projectId}`);
+    let rootAddress = project.serviceAddress;
+    if (!rootAddress) {
+        const objects = await localProject.listObjects(projectId);
+        if (objects.length === 0) {
+            throw new Error("Cannot build graph: project has no objects and no service_address");
+        }
+        const coreObj = objects.find(o => o.role === "core");
+        rootAddress = (coreObj ?? objects[0]).objectAddress;
+    }
+    const builder = new GraphBuilder({
+        maxDepth: v.max_depth ?? 3,
+        enableRegistrar: v.enable_registrar ?? true,
+        enablePotential: v.enable_potential ?? false,
+        projectId,
+        network: project.network,
+    });
+    const result = await builder.buildRelationshipGraph(rootAddress);
+    const edgesBySource = {};
+    for (const edge of result.graph.edges) {
+        const src = edge.edgeSource ?? "unknown";
+        edgesBySource[src] = (edgesBySource[src] ?? 0) + 1;
+    }
+    return {
+        action: "build_graph",
+        nodeCount: result.graph.nodes.length,
+        edgeCount: result.graph.edges.length,
+        edgesBySource,
+        reputationCount: result.reputation.size,
+        builtAt: result.graph.builtAt,
+    };
+}
+export async function handleGetGraph(v) {
+    const projectId = await resolveProjectId(v);
+    const edges = await localProject.getGraph(projectId);
+    return {
+        action: "get_graph",
+        edges: edges.map(e => ({
+            sourceObject: e.sourceObject,
+            targetObject: e.targetObject,
+            edgeSource: e.edgeSource,
+            relationshipType: e.relationshipType,
+            fieldName: e.fieldName,
+            depth: e.depth,
+            verified: e.verified,
+            weight: e.weight,
+            direction: e.direction,
+        })),
+    };
+}
+export async function handleEvaluateProject(v) {
+    const projectId = await resolveProjectId(v);
+    const evalType = requireField(v.evaluation_type, "evaluation_type");
+    const project = await localProject.getProject(projectId);
+    if (!project)
+        throw new Error(`Project not found: ${projectId}`);
+    if (v.refresh_before_eval) {
+        await refreshProjectObjects(projectId, project.network);
+    }
+    const objects = await localProject.listObjects(projectId);
+    const edges = await localProject.getGraph(projectId);
+    const addresses = objects.map(o => o.objectAddress);
+    const cacheEntries = await localProject.getCachedObjects(addresses);
+    const objectCache = new Map();
+    for (const [addr, entry] of cacheEntries)
+        objectCache.set(addr, entry);
+    let llmPrompt;
+    if (evalType === "worth_buying" || evalType === "value") {
+        const assembler = new SemanticAssembler();
+        const reputation = new Map();
+        for (const edge of edges) {
+            if (edge.edgeSource === "registrar" && edge.relationshipType === "affiliation") {
+            }
+        }
+        const context = await assembler.assemble(project, objects, edges, reputation);
+        const promptResult = assembler.buildEvaluationPrompt(evalType, context);
+        llmPrompt = promptResult.prompt;
+    }
+    const evalInput = {
+        project,
+        objects,
+        edges: edges,
+        objectCache: objectCache,
+        reputation: undefined,
+    };
+    const result = runEvaluation(evalInput, evalType, llmPrompt);
+    let evaluationId = "";
+    if (!result.needsLlm) {
+        const evalInput2 = {
+            projectId,
+            evalType,
+            score: result.score,
+            summary: result.summary,
+            details: {
+                criterionScores: result.criterionScores,
+                findings: result.findings,
+                strengths: result.strengths,
+            },
+        };
+        const saved = await localProject.saveEvaluation(evalInput2);
+        evaluationId = saved.id;
+    }
+    return {
+        action: "evaluate_project",
+        evaluationType: result.evaluationType,
+        score: result.score,
+        summary: result.summary,
+        criterionScores: result.criterionScores,
+        findings: result.findings,
+        strengths: result.strengths,
+        needsLlm: result.needsLlm,
+        llmPrompt: result.llmPrompt,
+        evaluationId,
+    };
+}
+export async function handleSaveEvaluation(v) {
+    const projectId = await resolveProjectId(v);
+    const evalType = requireField(v.evaluation_type, "evaluation_type");
+    const score = requireField(v.eval_score, "eval_score");
+    const summary = v.eval_summary ?? "";
+    const details = v.eval_details ?? {};
+    const saved = await localProject.saveEvaluation({
+        projectId,
+        evalType,
+        score,
+        summary,
+        details,
+    });
+    return {
+        action: "save_evaluation",
+        evaluation: {
+            id: saved.id,
+            evalType: saved.evalType,
+            score: saved.score,
+            summary: saved.summary,
+            evaluatedAt: saved.evaluatedAt,
+        },
+    };
+}
+export async function handleCompareProjects(v) {
+    const projectIds = requireField(v.compare_project_ids, "compare_project_ids");
+    const evalType = (v.evaluation_type ?? "worth_buying");
+    const entries = [];
+    for (const pid of projectIds) {
+        const project = await localProject.getProject(pid);
+        if (!project)
+            continue;
+        const evals = await localProject.listEvaluations(pid, { evalType });
+        const latest = evals[0];
+        entries.push({
+            projectId: pid,
+            projectName: project.name,
+            score: latest?.score ?? null,
+            summary: latest?.summary ?? null,
+            evaluatedAt: latest?.evaluatedAt ?? null,
+        });
+    }
+    const comparison = compareProjects(entries, evalType);
+    return {
+        action: "compare_projects",
+        evaluationType: comparison.evaluationType,
+        ranking: comparison.ranking,
+        bestProjectId: comparison.bestProjectId,
+    };
+}
+async function refreshProjectObjects(projectId, network) {
+    const objects = await localProject.listObjects(projectId);
+    const addresses = objects.map(o => o.objectAddress);
+    if (addresses.length === 0)
+        return { refreshedCount: 0, failedCount: 0 };
+    let refreshedCount = 0;
+    let failedCount = 0;
+    const BATCH_SIZE = 50;
+    for (let i = 0; i < addresses.length; i += BATCH_SIZE) {
+        const batch = addresses.slice(i, i + BATCH_SIZE);
+        try {
+            const response = await query_objects({
+                objects: batch,
+                no_cache: true,
+                network,
+            });
+            for (const obj of response?.objects ?? []) {
+                if (obj?.object) {
+                    await localProject.cacheObject(obj.object, obj.type ?? null, JSON.stringify(obj), network);
+                    refreshedCount++;
+                }
+            }
+        }
+        catch {
+            failedCount += batch.length;
+        }
+    }
+    return { refreshedCount, failedCount };
+}
+export async function handleRefreshObjects(v) {
+    const projectId = await resolveProjectId(v);
+    const project = await localProject.getProject(projectId);
+    if (!project)
+        throw new Error(`Project not found: ${projectId}`);
+    const network = project.network;
+    const { refreshedCount, failedCount } = await refreshProjectObjects(projectId, network);
+    return {
+        action: "refresh_objects",
+        refreshedCount,
+        failedCount,
+        refreshedAt: Date.now(),
+    };
+}
+export async function handleDeleteProject(v) {
+    const id = await resolveProjectId(v);
+    await localProject.deleteProject(id);
+    return { action: "delete_project", deleted: true };
+}
+export async function handleGetObjectDiff(v) {
+    const address = requireField(v.diff_address, "diff_address");
+    const fromTime = requireField(v.diff_from_time, "diff_from_time");
+    const toTime = requireField(v.diff_to_time, "diff_to_time");
+    const diff = await localProject.getObjectDiff(address, fromTime, toTime);
+    return {
+        action: "get_object_diff",
+        address: diff.address,
+        fromTime: diff.fromTime,
+        toTime: diff.toTime,
+        changedFields: diff.changedFields.map(f => ({
+            fieldPath: f.fieldPath,
+            oldValue: f.oldValue,
+            newValue: f.newValue,
+            changeType: f.changeType,
+        })),
+    };
+}

package/dist/project/index.d.ts

@@ -58,6 +58,7 @@ export declare function queryProjectObjects(prefix: string): Promise<{
     address?: string;
     type?: string;
     version?: string;
+    tags?: string[];
 }[]>;
 export declare function queryShareableObjects(): Promise<{
     name?: string;

package/dist/project/index.js

@@ -2,10 +2,9 @@ import { normalizeForProject, extractProjectPrefix, extractAllProjectVersions, T
 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 { LocalMark } from "@wowok/wowok";
+import { LocalMark, getWowMcpDir } from "@wowok/wowok";
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
 import { dirname, join } from "path";
-import { homedir } from "os";
 import * as ProjectStore from "./project-store.js";
 export * from "./namespace.js";
 export * from "./graph.js";
@@ -217,7 +216,30 @@ function extractAddressFromResult(result) {
     return undefined;
 }
 export async function queryProjects() {
-    return listProjects();
+    const tagProjects = await listProjects();
+    try {
+        const { LocalProject } = await import("@wowok/wowok");
+        const sqliteProjects = await LocalProject.Instance().listProjects();
+        const sqliteInfos = sqliteProjects.map(p => ({
+            prefix: p.prefix,
+            objectCount: 0,
+            types: [],
+            versions: p.currentVersion ? [p.currentVersion] : [],
+            objects: [],
+            ...p,
+        }));
+        const merged = new Map();
+        for (const p of tagProjects)
+            merged.set(p.prefix, p);
+        for (const p of sqliteInfos) {
+            if (!merged.has(p.prefix))
+                merged.set(p.prefix, p);
+        }
+        return Array.from(merged.values());
+    }
+    catch {
+        return tagProjects;
+    }
 }
 export async function queryProjectObjects(prefix) {
     return listProjectObjects(prefix);
@@ -247,10 +269,7 @@ export function queryGraphStats() {
     };
 }
 function graphFilePath() {
-    const dir = process.env.WOWOK_CONFIG_DIR
-        ? process.env.WOWOK_CONFIG_DIR
-        : join(homedir(), ".wowok");
-    return join(dir, "project-graph.json");
+    return join(getWowMcpDir(), "project-graph.json");
 }
 export function saveGraph() {
     const path = graphFilePath();

package/dist/project/project-store.js

@@ -1,12 +1,9 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, copyFileSync, statSync, appendFileSync, } from "fs";
 import { dirname, join } from "path";
-import { homedir } from "os";
+import { getWowMcpDir } from "@wowok/wowok";
 export const CURRENT_SCHEMA_VERSION = "1.0.0";
 export function projectsRootDir() {
-    const base = process.env.WOWOK_CONFIG_DIR
-        ? process.env.WOWOK_CONFIG_DIR
-        : join(homedir(), ".wowok");
-    return join(base, "projects");
+    return join(getWowMcpDir(), "projects");
 }
 export function projectDir(prefix, version) {
     return join(projectsRootDir(), `${prefix}_${version}`);

package/dist/project/query.d.ts

@@ -9,6 +9,7 @@ export interface ProjectInfo {
         address?: string;
         type?: string;
         version?: string;
+        tags?: string[];
     }>;
 }
 export interface DependencyTrace {

package/dist/project/query.js

@@ -42,6 +42,7 @@ export async function listProjects() {
                     address: m.address,
                     type,
                     version: v,
+                    tags: m.tags,
                 });
             }
         }
@@ -68,6 +69,7 @@ export async function listProjectObjects(prefix) {
             address: m.address,
             type: typeTag?.slice(TAG_PREFIX.type.length),
             version: matched.version,
+            tags: m.tags,
         });
     }
     return results;