@wowok/agent-mcp 2.2.13 → 2.2.15

package/dist/docs/loader.js

@@ -1,177 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,325 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

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