@agent-workspace/mcp-server 0.2.1 → 0.5.0

package/README.md

@@ -28,28 +28,65 @@ It will auto-discover the AWP workspace from the current directory (or use `AWP_
 
 ## Tools
 
+### Core Identity & Context
+
 | Tool | Description |
 |------|-------------|
 | `awp_read_identity` | Read agent identity (name, capabilities, DID) |
 | `awp_read_soul` | Read behavioral constraints (values, boundaries, governance) |
 | `awp_read_user` | Read human profile |
-| `awp_read_memory` | Read memory (daily or long-term) |
-| `awp_write_memory` | Log structured memory entries |
+| `awp_read_agents` | Read operations config (AGENTS.md) |
+| `awp_read_tools` | Read tools config (TOOLS.md) |
+| `awp_read_heartbeat` | Read heartbeat config (HEARTBEAT.md) |
+
+### Memory Operations
+
+| Tool | Description |
+|------|-------------|
+| `awp_read_memory` | Read memory (daily, longterm, or recent logs) |
+| `awp_write_memory` | Log structured memory entries to daily log |
+
+### Knowledge Artifacts (SMP)
+
+| Tool | Description |
+|------|-------------|
 | `awp_artifact_read` | Read a knowledge artifact by slug |
-| `awp_artifact_write` | Create or update a knowledge artifact |
+| `awp_artifact_write` | Create or update a knowledge artifact with versioning |
 | `awp_artifact_list` | List all artifacts (optional tag filter) |
 | `awp_artifact_search` | Search artifacts by content, title, or tags |
-| `awp_workspace_status` | Workspace summary (files present, memory count, artifact count) |
+
+### Reputation (RDP)
+
+| Tool | Description |
+|------|-------------|
+| `awp_reputation_query` | Query reputation profiles with time-based decay applied |
+| `awp_reputation_signal` | Log reputation signals (uses EWMA with decay) |
+
+### Delegation Contracts (RDP)
+
+| Tool | Description |
+|------|-------------|
+| `awp_contract_create` | Create delegation contracts between agents |
+| `awp_contract_evaluate` | Evaluate contracts and generate reputation signals |
+| `awp_contract_list` | List all contracts with optional status filter |
+
+### Workspace Management
+
+| Tool | Description |
+|------|-------------|
+| `awp_workspace_status` | Workspace health check (files present, stats) |
 
 ## How It Works
 
-The MCP server reads and writes AWP workspace files directly — no database, no daemon. Your agent's identity, memory, and knowledge artifacts are just Markdown files with YAML frontmatter, stored in a directory and compatible with Git.
+The MCP server reads and writes AWP workspace files directly — no database, no daemon. Your agent's identity, memory, knowledge artifacts, and reputation profiles are just Markdown files with YAML frontmatter, stored in a directory and compatible with Git.
 
 When an AI agent connects via MCP, it can:
 - **Read** its identity, soul, and user context at the start of each session
 - **Write** memory entries as it works
 - **Create and update** knowledge artifacts with full provenance tracking
 - **Search** its accumulated knowledge
+- **Query and update** reputation profiles for itself and other agents
+- **Create and evaluate** delegation contracts for multi-agent coordination
 
 ## Part of AWP
 

package/dist/index.d.ts

@@ -1,3 +1,9 @@
 #!/usr/bin/env node
+/**
+ * AWP MCP Server
+ *
+ * MCP server exposing Agent Workspace Protocol operations.
+ * Plug any AWP workspace into any MCP client.
+ */
 export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA;;;;;GAKG"}

package/dist/index.js

@@ -1,578 +1,40 @@
 #!/usr/bin/env node
+/**
+ * AWP MCP Server
+ *
+ * MCP server exposing Agent Workspace Protocol operations.
+ * Plug any AWP workspace into any MCP client.
+ */
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import * as z from "zod";
-import { readFile, writeFile, readdir, mkdir, access } from "node:fs/promises";
-import { join } from "node:path";
-import matter from "gray-matter";
-import { AWP_VERSION, SMP_VERSION, MEMORY_DIR, ARTIFACTS_DIR } from "@agent-workspace/core";
+import { AWP_VERSION } from "@agent-workspace/core";
+// Tool registration modules
+import { registerIdentityTools } from "./tools/identity.js";
+import { registerMemoryTools } from "./tools/memory.js";
+import { registerArtifactTools } from "./tools/artifact.js";
+import { registerStatusTools } from "./tools/status.js";
+import { registerReputationTools } from "./tools/reputation.js";
+import { registerContractTools } from "./tools/contract.js";
+import { registerProjectTools } from "./tools/project.js";
+import { registerTaskTools } from "./tools/task.js";
+import { registerConfigTools } from "./tools/config.js";
+import { registerSwarmTools } from "./tools/swarm.js";
+// Create MCP server
 const server = new McpServer({
     name: "awp-workspace",
     version: AWP_VERSION,
 });
-/**
- * Resolve workspace root from the AWP_WORKSPACE env var or cwd
- */
-function getWorkspaceRoot() {
-    return process.env.AWP_WORKSPACE || process.cwd();
-}
-async function fileExists(path) {
-    try {
-        await access(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Get agent DID from workspace manifest, or "anonymous"
- */
-async function getAgentDid(root) {
-    try {
-        const raw = await readFile(join(root, ".awp", "workspace.json"), "utf-8");
-        const manifest = JSON.parse(raw);
-        return manifest.agent?.did || "anonymous";
-    }
-    catch {
-        return "anonymous";
-    }
-}
-// --- Tool: awp_read_identity ---
-server.registerTool("awp_read_identity", {
-    title: "Read Agent Identity",
-    description: "Read this agent's identity (name, creature, capabilities, DID) from the AWP workspace",
-    inputSchema: {},
-}, async () => {
-    const root = getWorkspaceRoot();
-    const path = join(root, "IDENTITY.md");
-    try {
-        const raw = await readFile(path, "utf-8");
-        const { data, content } = matter(raw);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({ frontmatter: data, body: content.trim() }, null, 2),
-                },
-            ],
-        };
-    }
-    catch {
-        return {
-            content: [{ type: "text", text: "Error: IDENTITY.md not found" }],
-            isError: true,
-        };
-    }
-});
-// --- Tool: awp_read_soul ---
-server.registerTool("awp_read_soul", {
-    title: "Read Agent Soul",
-    description: "Read this agent's values, boundaries, and governance rules from the AWP workspace",
-    inputSchema: {},
-}, async () => {
-    const root = getWorkspaceRoot();
-    const path = join(root, "SOUL.md");
-    try {
-        const raw = await readFile(path, "utf-8");
-        const { data, content } = matter(raw);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({ frontmatter: data, body: content.trim() }, null, 2),
-                },
-            ],
-        };
-    }
-    catch {
-        return {
-            content: [{ type: "text", text: "Error: SOUL.md not found" }],
-            isError: true,
-        };
-    }
-});
-// --- Tool: awp_read_user ---
-server.registerTool("awp_read_user", {
-    title: "Read Human Profile",
-    description: "Read the human user's profile from the AWP workspace",
-    inputSchema: {},
-}, async () => {
-    const root = getWorkspaceRoot();
-    const path = join(root, "USER.md");
-    try {
-        const raw = await readFile(path, "utf-8");
-        const { data, content } = matter(raw);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({ frontmatter: data, body: content.trim() }, null, 2),
-                },
-            ],
-        };
-    }
-    catch {
-        return {
-            content: [{ type: "text", text: "Error: USER.md not found" }],
-            isError: true,
-        };
-    }
-});
-// --- Tool: awp_read_memory ---
-server.registerTool("awp_read_memory", {
-    title: "Read Memory",
-    description: "Read memory entries. Specify a date (YYYY-MM-DD) for daily logs, or 'longterm' for MEMORY.md, or 'recent' for the last 3 days",
-    inputSchema: {
-        target: z
-            .string()
-            .describe("Which memory to read: a date like '2026-01-30', 'longterm', or 'recent'"),
-    },
-}, async ({ target }) => {
-    const root = getWorkspaceRoot();
-    if (target === "longterm") {
-        const path = join(root, "MEMORY.md");
-        try {
-            const raw = await readFile(path, "utf-8");
-            const { data, content } = matter(raw);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({ frontmatter: data, body: content.trim() }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch {
-            return {
-                content: [
-                    { type: "text", text: "No long-term memory file exists yet." },
-                ],
-            };
-        }
-    }
-    if (target === "recent") {
-        const memDir = join(root, MEMORY_DIR);
-        try {
-            const files = await readdir(memDir);
-            const mdFiles = files
-                .filter((f) => f.endsWith(".md"))
-                .sort()
-                .reverse()
-                .slice(0, 3);
-            const results = [];
-            for (const f of mdFiles) {
-                const raw = await readFile(join(memDir, f), "utf-8");
-                const { data, content } = matter(raw);
-                results.push(`--- ${f} ---\n${JSON.stringify(data, null, 2)}\n${content.trim()}`);
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: results.length
-                            ? results.join("\n\n")
-                            : "No recent memory entries.",
-                    },
-                ],
-            };
-        }
-        catch {
-            return {
-                content: [{ type: "text", text: "No memory directory found." }],
-            };
-        }
-    }
-    // Specific date
-    const path = join(root, MEMORY_DIR, `${target}.md`);
-    try {
-        const raw = await readFile(path, "utf-8");
-        const { data, content } = matter(raw);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({ frontmatter: data, body: content.trim() }, null, 2),
-                },
-            ],
-        };
-    }
-    catch {
-        return {
-            content: [
-                { type: "text", text: `No memory entry for ${target}.` },
-            ],
-        };
-    }
-});
-// --- Tool: awp_write_memory ---
-server.registerTool("awp_write_memory", {
-    title: "Write Memory",
-    description: "Append an entry to today's memory log in the AWP workspace",
-    inputSchema: {
-        content: z.string().describe("The memory entry to log"),
-        tags: z
-            .array(z.string())
-            .optional()
-            .describe("Optional categorization tags"),
-    },
-}, async ({ content: entryContent, tags }) => {
-    const root = getWorkspaceRoot();
-    const memDir = join(root, MEMORY_DIR);
-    await mkdir(memDir, { recursive: true });
-    const date = new Date().toISOString().split("T")[0];
-    const time = new Date().toTimeString().slice(0, 5);
-    const filePath = join(memDir, `${date}.md`);
-    const entry = {
-        time,
-        content: entryContent,
-        tags: tags?.length ? tags : undefined,
-    };
-    let fileData;
-    try {
-        const raw = await readFile(filePath, "utf-8");
-        fileData = matter(raw);
-        if (!fileData.data.entries)
-            fileData.data.entries = [];
-        fileData.data.entries.push(entry);
-    }
-    catch {
-        fileData = {
-            data: {
-                awp: AWP_VERSION,
-                type: "memory-daily",
-                date,
-                entries: [entry],
-            },
-            content: `\n# ${date}\n\n`,
-        };
-    }
-    const tagStr = tags?.length ? ` [${tags.join(", ")}]` : "";
-    fileData.content += `- **${time}** — ${entryContent}${tagStr}\n`;
-    const output = matter.stringify(fileData.content, fileData.data);
-    await writeFile(filePath, output, "utf-8");
-    return {
-        content: [
-            {
-                type: "text",
-                text: `Logged to memory/${date}.md at ${time}`,
-            },
-        ],
-    };
-});
-// --- Tool: awp_artifact_read ---
-server.registerTool("awp_artifact_read", {
-    title: "Read Knowledge Artifact",
-    description: "Read a knowledge artifact by slug. Returns metadata (title, version, confidence, provenance) and body content.",
-    inputSchema: {
-        slug: z.string().describe("Artifact slug (e.g., 'llm-context-research')"),
-    },
-}, async ({ slug }) => {
-    const root = getWorkspaceRoot();
-    const path = join(root, ARTIFACTS_DIR, `${slug}.md`);
-    try {
-        const raw = await readFile(path, "utf-8");
-        const { data, content } = matter(raw);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({ frontmatter: data, body: content.trim() }, null, 2),
-                },
-            ],
-        };
-    }
-    catch {
-        return {
-            content: [
-                { type: "text", text: `Artifact "${slug}" not found.` },
-            ],
-            isError: true,
-        };
-    }
-});
-// --- Tool: awp_artifact_write ---
-server.registerTool("awp_artifact_write", {
-    title: "Write Knowledge Artifact",
-    description: "Create or update a knowledge artifact. If the artifact exists, increments version and appends provenance. If new, creates it with version 1.",
-    inputSchema: {
-        slug: z.string().describe("Artifact slug (lowercase, hyphens only)"),
-        title: z.string().optional().describe("Title (required for new artifacts)"),
-        content: z.string().describe("Markdown body content"),
-        tags: z.array(z.string()).optional().describe("Categorization tags"),
-        confidence: z
-            .number()
-            .min(0)
-            .max(1)
-            .optional()
-            .describe("Confidence score (0.0-1.0)"),
-        message: z.string().optional().describe("Commit message for provenance"),
-    },
-}, async ({ slug, title, content: bodyContent, tags, confidence, message }) => {
-    const root = getWorkspaceRoot();
-    const artifactsDir = join(root, ARTIFACTS_DIR);
-    await mkdir(artifactsDir, { recursive: true });
-    const filePath = join(artifactsDir, `${slug}.md`);
-    const did = await getAgentDid(root);
-    const now = new Date().toISOString();
-    let fileData;
-    let version;
-    let isNew = false;
-    try {
-        const raw = await readFile(filePath, "utf-8");
-        fileData = matter(raw);
-        // Update existing
-        fileData.data.version = (fileData.data.version || 1) + 1;
-        version = fileData.data.version;
-        fileData.data.lastModified = now;
-        fileData.data.modifiedBy = did;
-        fileData.content = `\n${bodyContent}\n`;
-        if (confidence !== undefined)
-            fileData.data.confidence = confidence;
-        if (tags)
-            fileData.data.tags = tags;
-        if (title)
-            fileData.data.title = title;
-        // Add author if new
-        if (!fileData.data.authors?.includes(did)) {
-            if (!fileData.data.authors)
-                fileData.data.authors = [];
-            fileData.data.authors.push(did);
-        }
-        // Append provenance
-        if (!fileData.data.provenance)
-            fileData.data.provenance = [];
-        fileData.data.provenance.push({
-            agent: did,
-            action: "updated",
-            timestamp: now,
-            message,
-            confidence,
-        });
-    }
-    catch {
-        // Create new
-        isNew = true;
-        version = 1;
-        const artifactTitle = title ||
-            slug
-                .split("-")
-                .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
-                .join(" ");
-        fileData = {
-            data: {
-                awp: AWP_VERSION,
-                smp: SMP_VERSION,
-                type: "knowledge-artifact",
-                id: `artifact:${slug}`,
-                title: artifactTitle,
-                authors: [did],
-                version: 1,
-                confidence,
-                tags: tags?.length ? tags : undefined,
-                created: now,
-                lastModified: now,
-                modifiedBy: did,
-                provenance: [
-                    {
-                        agent: did,
-                        action: "created",
-                        timestamp: now,
-                        message,
-                    },
-                ],
-            },
-            content: `\n${bodyContent}\n`,
-        };
-    }
-    const output = matter.stringify(fileData.content, fileData.data);
-    await writeFile(filePath, output, "utf-8");
-    return {
-        content: [
-            {
-                type: "text",
-                text: `${isNew ? "Created" : "Updated"} artifacts/${slug}.md (version ${version})`,
-            },
-        ],
-    };
-});
-// --- Tool: awp_artifact_list ---
-server.registerTool("awp_artifact_list", {
-    title: "List Knowledge Artifacts",
-    description: "List all knowledge artifacts in the workspace with metadata",
-    inputSchema: {
-        tag: z.string().optional().describe("Filter by tag"),
-    },
-}, async ({ tag }) => {
-    const root = getWorkspaceRoot();
-    const artifactsDir = join(root, ARTIFACTS_DIR);
-    let files;
-    try {
-        files = await readdir(artifactsDir);
-    }
-    catch {
-        return {
-            content: [
-                { type: "text", text: JSON.stringify({ artifacts: [] }, null, 2) },
-            ],
-        };
-    }
-    const mdFiles = files.filter((f) => f.endsWith(".md")).sort();
-    const artifacts = [];
-    for (const f of mdFiles) {
-        try {
-            const raw = await readFile(join(artifactsDir, f), "utf-8");
-            const { data } = matter(raw);
-            if (data.type !== "knowledge-artifact")
-                continue;
-            if (tag && !data.tags?.some((t) => t.toLowerCase() === tag.toLowerCase())) {
-                continue;
-            }
-            artifacts.push({
-                slug: f.replace(/\.md$/, ""),
-                title: data.title,
-                version: data.version,
-                confidence: data.confidence,
-                tags: data.tags,
-                authors: data.authors,
-                lastModified: data.lastModified,
-            });
-        }
-        catch {
-            // Skip unparseable
-        }
-    }
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify({ artifacts }, null, 2),
-            },
-        ],
-    };
-});
-// --- Tool: awp_artifact_search ---
-server.registerTool("awp_artifact_search", {
-    title: "Search Knowledge Artifacts",
-    description: "Search artifacts by title, tags, or body content",
-    inputSchema: {
-        query: z.string().describe("Search query"),
-    },
-}, async ({ query }) => {
-    const root = getWorkspaceRoot();
-    const artifactsDir = join(root, ARTIFACTS_DIR);
-    const queryLower = query.toLowerCase();
-    let files;
-    try {
-        files = await readdir(artifactsDir);
-    }
-    catch {
-        return {
-            content: [
-                { type: "text", text: JSON.stringify({ results: [] }, null, 2) },
-            ],
-        };
-    }
-    const mdFiles = files.filter((f) => f.endsWith(".md")).sort();
-    const results = [];
-    for (const f of mdFiles) {
-        try {
-            const raw = await readFile(join(artifactsDir, f), "utf-8");
-            const { data, content } = matter(raw);
-            if (data.type !== "knowledge-artifact")
-                continue;
-            const titleMatch = data.title?.toLowerCase().includes(queryLower);
-            const tagMatch = data.tags?.some((t) => t.toLowerCase().includes(queryLower));
-            const bodyMatch = content.toLowerCase().includes(queryLower);
-            if (titleMatch || tagMatch || bodyMatch) {
-                results.push({
-                    slug: f.replace(/\.md$/, ""),
-                    title: data.title,
-                    version: data.version,
-                    confidence: data.confidence,
-                    tags: data.tags,
-                    matchedIn: [
-                        titleMatch && "title",
-                        tagMatch && "tags",
-                        bodyMatch && "body",
-                    ].filter(Boolean),
-                });
-            }
-        }
-        catch {
-            // Skip
-        }
-    }
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify({ results }, null, 2),
-            },
-        ],
-    };
-});
-// --- Tool: awp_workspace_status ---
-server.registerTool("awp_workspace_status", {
-    title: "Workspace Status",
-    description: "Get AWP workspace health status — manifest info, file presence, memory stats, artifact count",
-    inputSchema: {},
-}, async () => {
-    const root = getWorkspaceRoot();
-    const status = { root };
-    // Manifest
-    try {
-        const manifestRaw = await readFile(join(root, ".awp", "workspace.json"), "utf-8");
-        status.manifest = JSON.parse(manifestRaw);
-    }
-    catch {
-        status.manifest = null;
-        status.error = "No .awp/workspace.json found";
-    }
-    // File presence
-    const fileChecks = [
-        "IDENTITY.md",
-        "SOUL.md",
-        "AGENTS.md",
-        "USER.md",
-        "TOOLS.md",
-        "HEARTBEAT.md",
-        "MEMORY.md",
-    ];
-    status.files = {};
-    for (const f of fileChecks) {
-        status.files[f] = await fileExists(join(root, f));
-    }
-    // Memory stats
-    try {
-        const memDir = join(root, MEMORY_DIR);
-        const files = await readdir(memDir);
-        const mdFiles = files.filter((f) => f.endsWith(".md"));
-        status.memory = {
-            logCount: mdFiles.length,
-            latest: mdFiles.sort().reverse()[0] || null,
-        };
-    }
-    catch {
-        status.memory = { logCount: 0, latest: null };
-    }
-    // Artifact stats
-    try {
-        const artDir = join(root, ARTIFACTS_DIR);
-        const files = await readdir(artDir);
-        const mdFiles = files.filter((f) => f.endsWith(".md"));
-        status.artifacts = { count: mdFiles.length };
-    }
-    catch {
-        status.artifacts = { count: 0 };
-    }
-    return {
-        content: [
-            { type: "text", text: JSON.stringify(status, null, 2) },
-        ],
-    };
-});
+// Register all tool groups
+registerIdentityTools(server);
+registerMemoryTools(server);
+registerArtifactTools(server);
+registerStatusTools(server);
+registerReputationTools(server);
+registerContractTools(server);
+registerProjectTools(server);
+registerTaskTools(server);
+registerConfigTools(server);
+registerSwarmTools(server);
 // Start the server
 const transport = new StdioServerTransport();
 await server.connect(transport);