@wowok/agent-mcp 2.2.11 → 2.2.13

package/dist/docs/index.d.ts

@@ -0,0 +1,3 @@
+export type { Document, DocumentCategory, DocumentIndex, SearchResult, SchemaInfo, ExampleInfo, LearnRequest, LearnResponse, LearnAction, } from "./types.js";
+export { loadAllDocuments, isDocumentationAvailable, getDocStats, } from "./loader.js";
+export { processLearnRequest, searchDocuments, getOperationSchema, getToolSchema, getExampleInfo, getGuide, listOperations, listExamples, } from "./search.js";

package/dist/docs/index.js

@@ -0,0 +1,2 @@
+export { loadAllDocuments, isDocumentationAvailable, getDocStats, } from "./loader.js";
+export { processLearnRequest, searchDocuments, getOperationSchema, getToolSchema, getExampleInfo, getGuide, listOperations, listExamples, } from "./search.js";

package/dist/docs/loader.d.ts

@@ -0,0 +1,12 @@
+import type { Document, DocumentIndex } from "./types.js";
+export declare function loadAllDocuments(): {
+    documents: Document[];
+    index: DocumentIndex;
+};
+export declare function isDocumentationAvailable(): boolean;
+export declare function getDocStats(): {
+    total: number;
+    skills: number;
+    examples: number;
+    available: boolean;
+};

package/dist/docs/loader.js

@@ -0,0 +1,177 @@
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const DOCS_PATHS = {
+    skills: path.join(__dirname, "../../docs/skills"),
+    examples: path.join(__dirname, "../../docs/examples"),
+};
+function getDocsPath(type) {
+    return DOCS_PATHS[type];
+}
+function extractTitle(content, filename) {
+    const h1Match = content.match(/^#\s+(.+)$/m);
+    if (h1Match) {
+        return h1Match[1].trim();
+    }
+    return filename.replace(/\.md$/, "").replace(/[_-]/g, " ");
+}
+function determineCategory(filePath, content) {
+    const normalizedPath = filePath.toLowerCase();
+    if (normalizedPath.includes("examples")) {
+        return "example";
+    }
+    if (normalizedPath.includes("onchain_operations")) {
+        return "operation-schema";
+    }
+    if (normalizedPath.match(/schema-.*\.md$/)) {
+        return "tool-schema";
+    }
+    if (normalizedPath.includes("_common.md") || normalizedPath.includes("_index.md")) {
+        return "common";
+    }
+    if (normalizedPath.includes("wowok.md")) {
+        return "skill-overview";
+    }
+    return "common";
+}
+function extractTags(content) {
+    const tags = [];
+    const keywordsMatch = content.match(/keywords?:\s*([^\n]+)/i);
+    if (keywordsMatch) {
+        const keywords = keywordsMatch[1]
+            .split(/[,;]/)
+            .map((k) => k.trim().toLowerCase())
+            .filter((k) => k.length > 0);
+        tags.push(...keywords);
+    }
+    const operationTypes = [
+        "service", "machine", "progress", "repository", "arbitration",
+        "contact", "treasury", "reward", "allocation", "permission",
+        "guard", "personal", "payment", "demand", "order", "gen_passport"
+    ];
+    for (const op of operationTypes) {
+        const regex = new RegExp(`\\b${op}\\b`, "i");
+        if (regex.test(content)) {
+            tags.push(op);
+        }
+    }
+    return [...new Set(tags)];
+}
+function loadDocument(filePath, basePath) {
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        const relativePath = path.relative(basePath, filePath);
+        const filename = path.basename(filePath);
+        const stats = fs.statSync(filePath);
+        return {
+            id: relativePath.replace(/\\/g, "/"),
+            path: filePath,
+            title: extractTitle(content, filename),
+            content,
+            category: determineCategory(filePath, content),
+            tags: extractTags(content),
+            lastModified: stats.mtimeMs,
+        };
+    }
+    catch (error) {
+        console.error(`Failed to load document: ${filePath}`, error);
+        return null;
+    }
+}
+function findMarkdownFiles(dir) {
+    const files = [];
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                files.push(...findMarkdownFiles(fullPath));
+            }
+            else if (entry.name.endsWith(".md")) {
+                files.push(fullPath);
+            }
+        }
+    }
+    catch (error) {
+        console.warn(`Cannot read directory: ${dir}`);
+    }
+    return files;
+}
+function loadSkillsDocs() {
+    const skillsPath = getDocsPath("skills");
+    const files = findMarkdownFiles(skillsPath);
+    return files
+        .map((file) => loadDocument(file, skillsPath))
+        .filter((doc) => doc !== null);
+}
+function loadExamplesDocs() {
+    const examplesPath = getDocsPath("examples");
+    const files = findMarkdownFiles(examplesPath);
+    return files
+        .map((file) => loadDocument(file, examplesPath))
+        .filter((doc) => doc !== null);
+}
+function buildIndex(documents) {
+    const index = {
+        operations: new Map(),
+        tools: new Map(),
+        examples: new Map(),
+        guides: new Map(),
+        all: documents,
+    };
+    for (const doc of documents) {
+        if (doc.category === "operation-schema") {
+            const operationMatch = doc.id.match(/onchain_operations\/(.+)\.md$/);
+            if (operationMatch && !operationMatch[1].startsWith("_")) {
+                index.operations.set(operationMatch[1], doc);
+            }
+        }
+        if (doc.category === "tool-schema") {
+            const toolMatch = doc.id.match(/schema-(.+)\.md$/);
+            if (toolMatch) {
+                index.tools.set(toolMatch[1], doc);
+            }
+        }
+        if (doc.category === "example") {
+            const exampleMatch = doc.id.match(/^([^/]+)\//);
+            if (exampleMatch) {
+                const exampleName = exampleMatch[1];
+                if (!index.examples.has(exampleName)) {
+                    index.examples.set(exampleName, []);
+                }
+                index.examples.get(exampleName).push(doc);
+            }
+        }
+        if (doc.category === "common" || doc.category === "skill-overview") {
+            const guideKey = doc.id.replace(/\.md$/, "");
+            index.guides.set(guideKey, doc);
+        }
+    }
+    return index;
+}
+export function loadAllDocuments() {
+    const skillsDocs = loadSkillsDocs();
+    const examplesDocs = loadExamplesDocs();
+    const allDocs = [...skillsDocs, ...examplesDocs];
+    const index = buildIndex(allDocs);
+    return { documents: allDocs, index };
+}
+export function isDocumentationAvailable() {
+    const skillsPath = getDocsPath("skills");
+    const examplesPath = getDocsPath("examples");
+    return fs.existsSync(skillsPath) && fs.existsSync(examplesPath);
+}
+export function getDocStats() {
+    const skillsPath = getDocsPath("skills");
+    const examplesPath = getDocsPath("examples");
+    const skillsFiles = fs.existsSync(skillsPath) ? findMarkdownFiles(skillsPath).length : 0;
+    const examplesFiles = fs.existsSync(examplesPath) ? findMarkdownFiles(examplesPath).length : 0;
+    return {
+        total: skillsFiles + examplesFiles,
+        skills: skillsFiles,
+        examples: examplesFiles,
+        available: fs.existsSync(skillsPath) && fs.existsSync(examplesPath),
+    };
+}

package/dist/docs/search.d.ts

@@ -0,0 +1,17 @@
+import type { Document, DocumentIndex, SearchResult, SchemaInfo, ExampleInfo, LearnRequest, LearnResponse } from "./types.js";
+export declare function searchDocuments(index: DocumentIndex, query: string, limit?: number): SearchResult[];
+export declare function getOperationSchema(index: DocumentIndex, operationType: string): SchemaInfo | null;
+export declare function getToolSchema(index: DocumentIndex, toolName: string): SchemaInfo | null;
+export declare function getExampleInfo(index: DocumentIndex, exampleName: string): ExampleInfo | null;
+export declare function getGuide(index: DocumentIndex, topic: string): Document | null;
+export declare function listOperations(index: DocumentIndex): Array<{
+    name: string;
+    title: string;
+    description: string;
+}>;
+export declare function listExamples(index: DocumentIndex): Array<{
+    name: string;
+    title: string;
+    docCount: number;
+}>;
+export declare function processLearnRequest(index: DocumentIndex, request: LearnRequest): LearnResponse;

package/dist/docs/search.js

@@ -0,0 +1,325 @@
+function calculateScore(document, query) {
+    const lowerQuery = query.toLowerCase();
+    const lowerTitle = document.title.toLowerCase();
+    const lowerContent = document.content.toLowerCase();
+    const lowerTags = document.tags.map((t) => t.toLowerCase());
+    let score = 0;
+    if (lowerTitle === lowerQuery) {
+        score += 100;
+    }
+    else if (lowerTitle.includes(lowerQuery)) {
+        score += 50;
+    }
+    if (lowerTags.some((tag) => tag === lowerQuery)) {
+        score += 40;
+    }
+    if (lowerTags.some((tag) => tag.includes(lowerQuery))) {
+        score += 20;
+    }
+    const contentMatches = (lowerContent.match(new RegExp(lowerQuery, "g")) || []).length;
+    score += Math.min(contentMatches * 5, 30);
+    if (document.category === "operation-schema" && lowerQuery.match(/^(service|guard|machine|order)$/)) {
+        score += 10;
+    }
+    return score;
+}
+function extractSnippets(content, query, maxSnippets = 3) {
+    const lowerContent = content.toLowerCase();
+    const lowerQuery = query.toLowerCase();
+    const snippets = [];
+    const sentences = content.split(/[.!?\n]+/);
+    for (const sentence of sentences) {
+        if (sentence.toLowerCase().includes(lowerQuery) && sentence.trim().length > 20) {
+            snippets.push(sentence.trim());
+            if (snippets.length >= maxSnippets)
+                break;
+        }
+    }
+    return snippets;
+}
+export function searchDocuments(index, query, limit = 5) {
+    const results = [];
+    for (const doc of index.all) {
+        const score = calculateScore(doc, query);
+        if (score > 0) {
+            results.push({
+                document: doc,
+                score,
+                matches: extractSnippets(doc.content, query),
+            });
+        }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, limit);
+}
+export function getOperationSchema(index, operationType) {
+    const doc = index.operations.get(operationType.toLowerCase());
+    if (!doc)
+        return null;
+    const descMatch = doc.content.match(/>\s*([^\n]+)/);
+    const description = descMatch ? descMatch[1].trim() : "";
+    const schemaMatch = doc.content.match(/##\s*Data Schema\s*([\s\S]*?)(?=##|$)/);
+    const dataSchema = schemaMatch ? schemaMatch[1].trim() : undefined;
+    const relatedOps = [];
+    for (const [opName] of index.operations) {
+        if (opName !== operationType && doc.content.toLowerCase().includes(opName.toLowerCase())) {
+            relatedOps.push(opName);
+        }
+    }
+    return {
+        operationType,
+        title: doc.title,
+        description,
+        dataSchema,
+        relatedOperations: relatedOps.slice(0, 5),
+    };
+}
+export function getToolSchema(index, toolName) {
+    const doc = index.tools.get(toolName.toLowerCase());
+    if (!doc)
+        return null;
+    const descMatch = doc.content.match(/>\s*([^\n]+)/);
+    const description = descMatch ? descMatch[1].trim() : "";
+    return {
+        toolName,
+        title: doc.title,
+        description,
+    };
+}
+export function getExampleInfo(index, exampleName) {
+    const docs = index.examples.get(exampleName);
+    if (!docs || docs.length === 0)
+        return null;
+    const mainDoc = docs.find((d) => d.id.toLowerCase().includes(".md") && !d.id.toLowerCase().includes("test")) || docs[0];
+    const descMatch = mainDoc.content.match(/##\s*Overview\s*([\s\S]*?)(?=##|$)/);
+    const description = descMatch
+        ? descMatch[1].trim().slice(0, 200) + "..."
+        : mainDoc.content.slice(0, 200) + "...";
+    const testResults = docs.find((d) => d.id.toLowerCase().includes("testresult"));
+    return {
+        name: exampleName,
+        title: mainDoc.title,
+        description,
+        documents: docs,
+        testResults,
+    };
+}
+export function getGuide(index, topic) {
+    let doc = index.guides.get(topic.toLowerCase());
+    if (doc)
+        return doc;
+    const prefixes = ["", "_", "onchain_operations/", "schema-"];
+    for (const prefix of prefixes) {
+        doc = index.guides.get(`${prefix}${topic.toLowerCase()}`);
+        if (doc)
+            return doc;
+    }
+    for (const [key, value] of index.guides) {
+        if (key.includes(topic.toLowerCase())) {
+            return value;
+        }
+    }
+    return null;
+}
+export function listOperations(index) {
+    const operations = [];
+    for (const [name, doc] of index.operations) {
+        const descMatch = doc.content.match(/>\s*([^\n]+)/);
+        const description = descMatch ? descMatch[1].trim() : "";
+        operations.push({
+            name,
+            title: doc.title,
+            description,
+        });
+    }
+    return operations.sort((a, b) => a.name.localeCompare(b.name));
+}
+export function listExamples(index) {
+    const examples = [];
+    for (const [name, docs] of index.examples) {
+        const mainDoc = docs.find((d) => !d.id.toLowerCase().includes("test")) || docs[0];
+        examples.push({
+            name,
+            title: mainDoc.title,
+            docCount: docs.length,
+        });
+    }
+    return examples.sort((a, b) => a.name.localeCompare(b.name));
+}
+export function processLearnRequest(index, request) {
+    switch (request.action) {
+        case "search": {
+            if (!request.query) {
+                return {
+                    success: false,
+                    action: "search",
+                    data: null,
+                    message: "Search query is required",
+                };
+            }
+            const results = searchDocuments(index, request.query);
+            if (results.length === 0) {
+                return {
+                    success: true,
+                    action: "search",
+                    data: [],
+                    message: `No documents found for "${request.query}"`,
+                    suggestions: ["Try a different keyword", "Use 'list_operations' to see available operations", "Use 'list_examples' to see available examples"],
+                };
+            }
+            return {
+                success: true,
+                action: "search",
+                data: results.map((r) => ({
+                    title: r.document.title,
+                    category: r.document.category,
+                    path: r.document.id,
+                    score: r.score,
+                    snippets: r.matches,
+                })),
+                message: `Found ${results.length} document(s) for "${request.query}"`,
+            };
+        }
+        case "get_schema": {
+            const opType = request.operationType || request.topic;
+            const toolName = request.toolName;
+            if (opType) {
+                const schema = getOperationSchema(index, opType);
+                if (!schema) {
+                    return {
+                        success: false,
+                        action: "get_schema",
+                        data: null,
+                        message: `Operation schema not found: ${opType}`,
+                        suggestions: Array.from(index.operations.keys()).slice(0, 5),
+                    };
+                }
+                return {
+                    success: true,
+                    action: "get_schema",
+                    data: schema,
+                    message: `Schema for operation: ${opType}`,
+                };
+            }
+            if (toolName) {
+                const schema = getToolSchema(index, toolName);
+                if (!schema) {
+                    return {
+                        success: false,
+                        action: "get_schema",
+                        data: null,
+                        message: `Tool schema not found: ${toolName}`,
+                        suggestions: Array.from(index.tools.keys()).slice(0, 5),
+                    };
+                }
+                return {
+                    success: true,
+                    action: "get_schema",
+                    data: schema,
+                    message: `Schema for tool: ${toolName}`,
+                };
+            }
+            return {
+                success: false,
+                action: "get_schema",
+                data: null,
+                message: "operationType or toolName is required",
+            };
+        }
+        case "learn_example": {
+            const exampleName = request.example || request.topic;
+            if (!exampleName) {
+                return {
+                    success: false,
+                    action: "learn_example",
+                    data: null,
+                    message: "Example name is required",
+                };
+            }
+            const info = getExampleInfo(index, exampleName);
+            if (!info) {
+                const available = listExamples(index);
+                return {
+                    success: false,
+                    action: "learn_example",
+                    data: null,
+                    message: `Example not found: ${exampleName}`,
+                    suggestions: available.map((e) => e.name),
+                };
+            }
+            return {
+                success: true,
+                action: "learn_example",
+                data: {
+                    name: info.name,
+                    title: info.title,
+                    description: info.description,
+                    documents: info.documents.map((d) => ({
+                        title: d.title,
+                        path: d.id,
+                        category: d.category,
+                    })),
+                    hasTestResults: !!info.testResults,
+                },
+                message: `Example: ${info.title}`,
+            };
+        }
+        case "guide": {
+            const topic = request.topic || request.query;
+            if (!topic) {
+                return {
+                    success: false,
+                    action: "guide",
+                    data: null,
+                    message: "Topic is required",
+                };
+            }
+            const doc = getGuide(index, topic);
+            if (!doc) {
+                return {
+                    success: false,
+                    action: "guide",
+                    data: null,
+                    message: `Guide not found: ${topic}`,
+                    suggestions: ["Try 'WOWOK' for overview", "Try '_index' for operations index", "Use 'search' to find relevant content"],
+                };
+            }
+            return {
+                success: true,
+                action: "guide",
+                data: {
+                    title: doc.title,
+                    category: doc.category,
+                    content: doc.content,
+                    tags: doc.tags,
+                },
+                message: `Guide: ${doc.title}`,
+            };
+        }
+        case "list_operations": {
+            const operations = listOperations(index);
+            return {
+                success: true,
+                action: "list_operations",
+                data: operations,
+                message: `Available operations: ${operations.length}`,
+            };
+        }
+        case "list_examples": {
+            const examples = listExamples(index);
+            return {
+                success: true,
+                action: "list_examples",
+                data: examples,
+                message: `Available examples: ${examples.length}`,
+            };
+        }
+        default:
+            return {
+                success: false,
+                action: request.action,
+                data: null,
+                message: `Unknown action: ${request.action}`,
+            };
+    }
+}

package/dist/docs/types.d.ts

@@ -0,0 +1,55 @@
+export interface Document {
+    id: string;
+    path: string;
+    title: string;
+    content: string;
+    category: DocumentCategory;
+    tags: string[];
+    lastModified: number;
+}
+export type DocumentCategory = "skill-overview" | "operation-schema" | "tool-schema" | "example" | "common";
+export interface DocumentIndex {
+    operations: Map<string, Document>;
+    tools: Map<string, Document>;
+    examples: Map<string, Document[]>;
+    guides: Map<string, Document>;
+    all: Document[];
+}
+export interface SearchResult {
+    document: Document;
+    score: number;
+    matches: string[];
+}
+export interface SchemaInfo {
+    operationType?: string;
+    toolName?: string;
+    title: string;
+    description: string;
+    dataSchema?: string;
+    examples?: string[];
+    relatedOperations?: string[];
+}
+export interface ExampleInfo {
+    name: string;
+    title: string;
+    description: string;
+    documents: Document[];
+    testResults?: Document;
+}
+export type LearnAction = "search" | "get_schema" | "learn_example" | "guide" | "list_operations" | "list_examples";
+export interface LearnRequest {
+    action: LearnAction;
+    topic?: string;
+    query?: string;
+    example?: string;
+    operationType?: string;
+    toolName?: string;
+}
+export interface LearnResponse {
+    [key: string]: unknown;
+    success: boolean;
+    action: LearnAction;
+    data: unknown;
+    message: string;
+    suggestions?: string[];
+}

package/dist/docs/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -15642,6 +15642,15 @@ declare const WatchQueryOperationsSchema: z.ZodEffects<z.ZodUnion<[z.ZodDiscrimi
         cursor?: string | null | undefined;
         limit?: number | null | undefined;
     } | undefined;
+}>, z.ZodObject<{
+    query_type: z.ZodLiteral<"local_names">;
+    addresses: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    query_type: "local_names";
+    addresses: string[];
+}, {
+    query_type: "local_names";
+    addresses: string[];
 }>]>, z.ZodDiscriminatedUnion<"query_type", [z.ZodObject<{
     query_type: z.ZodLiteral<"onchain_personal_profile">;
     account: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
@@ -15775,6 +15784,9 @@ declare const WatchQueryOperationsSchema: z.ZodEffects<z.ZodUnion<[z.ZodDiscrimi
         cursor?: string | null | undefined;
         limit?: number | null | undefined;
     } | undefined;
+} | {
+    query_type: "local_names";
+    addresses: string[];
 } | {
     query_type: "onchain_personal_profile";
     no_cache?: boolean | undefined;