@wowok/agent-mcp 2.5.3 → 2.5.5

package/dist/project/handlers.d.ts

@@ -0,0 +1,152 @@
+import type { z } from "zod";
+import { type Project, type ProjectObject, type EvaluationType } from "@wowok/wowok";
+import type { ProjectOperationInputSchema } from "../schema/project/index.js";
+type ProjectInput = z.infer<typeof ProjectOperationInputSchema>;
+export declare function handleListProjects(v: ProjectInput): Promise<{
+    action: "list_projects";
+    items: {
+        objectCount: number;
+        objectTypes: string[];
+        id: string;
+        prefix: string;
+        name: string;
+        description: string | null;
+        industry: string | null;
+        perspective: import("@wowok/wowok").ProjectPerspective;
+        status: import("@wowok/wowok").ProjectStatus;
+        labels: string[] | null;
+        currentVersion: string | null;
+        serviceAddress: string | null;
+        defaultAccount: string | null;
+        network: string;
+        createdAt: number;
+        updatedAt: number;
+        metadata: Record<string, unknown> | null;
+    }[];
+    total: number;
+}>;
+export declare function handleCreateProject(v: ProjectInput): Promise<{
+    action: "create_project";
+    project: Project;
+}>;
+export declare function handleCreateProjectFromOnchain(v: ProjectInput): Promise<{
+    action: "create_project_from_onchain";
+    project: Project;
+    objects: ProjectObject[];
+    graphEdgeCount: number;
+}>;
+export declare function handleUpdateProject(v: ProjectInput): Promise<{
+    action: "update_project";
+    project: Project;
+}>;
+export declare function handleGetProjectDetail(v: ProjectInput): Promise<{
+    action: "get_project_detail";
+    project: Project;
+    objects: ProjectObject[];
+    graphEdgeCount: number;
+    evaluations: {
+        id: string;
+        evalType: EvaluationType;
+        score: number | null;
+        summary: string | null;
+        evaluatedAt: number;
+    }[];
+    versions: {
+        version: string;
+        description: string | null;
+        createdAt: number;
+    }[];
+}>;
+export declare function handleAddObject(v: ProjectInput): Promise<{
+    action: "add_object";
+    object: ProjectObject;
+}>;
+export declare function handleRemoveObject(v: ProjectInput): Promise<{
+    action: "remove_object";
+    removed: true;
+}>;
+export declare function handleUpdateObject(v: ProjectInput): Promise<{
+    action: "update_object";
+    object: ProjectObject;
+}>;
+export declare function handleCreateVersion(v: ProjectInput): Promise<{
+    action: "create_version";
+    version: {
+        version: string;
+        description: string | null;
+        createdAt: number;
+    };
+}>;
+export declare function handleBuildGraph(v: ProjectInput): Promise<{
+    action: "build_graph";
+    nodeCount: number;
+    edgeCount: number;
+    edgesBySource: Record<string, number>;
+    reputationCount: number;
+    builtAt: number;
+}>;
+export declare function handleGetGraph(v: ProjectInput): Promise<{
+    action: "get_graph";
+    edges: {
+        sourceObject: string;
+        targetObject: string;
+        edgeSource: import("@wowok/wowok").EdgeSource;
+        relationshipType: import("@wowok/wowok").RelationshipType;
+        fieldName: string | null;
+        depth: number;
+        verified: boolean;
+        weight: number;
+        direction: string | null;
+    }[];
+}>;
+export declare function handleEvaluateProject(v: ProjectInput): Promise<{
+    action: "evaluate_project";
+    evaluationType: EvaluationType;
+    score: number;
+    summary: string;
+    criterionScores: import("./evaluation.js").CriterionScore[];
+    findings: import("./evaluation.js").EvaluationFinding[];
+    strengths: string[];
+    needsLlm: boolean;
+    llmPrompt: string | undefined;
+    evaluationId: string;
+}>;
+export declare function handleSaveEvaluation(v: ProjectInput): Promise<{
+    action: "save_evaluation";
+    evaluation: {
+        id: string;
+        evalType: EvaluationType;
+        score: number | null;
+        summary: string | null;
+        evaluatedAt: number;
+    };
+}>;
+export declare function handleCompareProjects(v: ProjectInput): Promise<{
+    action: "compare_projects";
+    evaluationType: EvaluationType;
+    ranking: import("./evaluation.js").ProjectComparisonEntry[];
+    bestProjectId: string | null;
+}>;
+export declare function handleRefreshObjects(v: ProjectInput): Promise<{
+    action: "refresh_objects";
+    refreshedCount: number;
+    failedCount: number;
+    refreshedAt: number;
+}>;
+export declare function handleDeleteProject(v: ProjectInput): Promise<{
+    action: "delete_project";
+    deleted: true;
+}>;
+export declare function handleGetObjectDiff(v: ProjectInput): Promise<{
+    action: "get_object_diff";
+    address: string;
+    fromTime: number;
+    toTime: number;
+    changedFields: {
+        fieldPath: string;
+        oldValue: unknown;
+        newValue: unknown;
+        changeType: "modified" | "removed" | "added";
+    }[];
+}>;
+export {};

package/dist/project/handlers.js

@@ -0,0 +1,458 @@
+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 = await localProject.listObjects(p.id);
+        const types = new Set();
+        for (const o of objs) {
+            if (o.objectType)
+                types.add(o.objectType);
+        }
+        return {
+            ...p,
+            objectCount: objs.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);
+    }
+    return {
+        action: "create_project_from_onchain",
+        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);
+    return {
+        action: "get_project_detail",
+        project,
+        objects,
+        graphEdgeCount: edges.length,
+        evaluations: evaluations.map(e => ({
+            id: e.id,
+            evalType: e.evalType,
+            score: e.score,
+            summary: e.summary,
+            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);
+    const obj = await localProject.addObject(projectId, {
+        objectAddress,
+        objectType: v.object_type_add,
+        objectName: v.object_name_add,
+        role: v.object_role ?? "reference",
+        tags: v.object_tags_add,
+    });
+    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");
+        }
+        rootAddress = 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

@@ -217,7 +217,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);

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;