@atoms-tech/atoms-mcp 0.3.0 → 0.3.1

package/dist/server.js

@@ -1,679 +0,0 @@
-/**
- * ATOMS MCP Server — Tool registration and initialization.
- *
- * Registers 15 tools: 10 via server.registerTool(), 5 as MCP Apps via registerAtomsApp().
- * MCP App tools (mermaid, summary, trace) render interactive UIs in capable hosts
- * while falling back to text for non-UI clients.
- *
- * Naming: atoms_{action}_{resource} (snake_case with service prefix)
- * Server name: atoms-mcp-server (follows {service}-mcp-server convention)
- */
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
-import { logAudit, startTimer } from "./middleware/audit.js";
-import { checkRateLimit } from "./middleware/rate-limiter.js";
-import { getClient, getUserId } from "./db/client.js";
-import { formatErrorResult, rateLimitError } from "./tools/_base.js";
-import { registerAtomsApp } from "./apps/register.js";
-import { randomUUID } from "crypto";
-export const server = new McpServer({
-    name: "atoms-mcp-server",
-    version: "0.1.0",
-});
-// Session ID for grouping tool calls in audit log
-const SESSION_ID = randomUUID();
-const CLIENT_NAME = process.env.ATOMS_CLIENT_NAME ?? "unknown";
-/**
- * Wrap a tool handler with rate limiting + audit logging.
- * This is the middleware pipeline for every tool call.
- */
-function withMiddleware(toolName, handler) {
-    return async (params) => {
-        // Rate limit check
-        let userId;
-        try {
-            await getClient(); // ensure auth
-            userId = getUserId();
-        }
-        catch {
-            // Auth will fail inside the handler with proper error
-            return handler(params);
-        }
-        const rateCheck = checkRateLimit(userId);
-        if (!rateCheck.allowed) {
-            return formatErrorResult(rateLimitError(rateCheck.retryAfterSeconds));
-        }
-        // Execute with timing
-        const elapsed = startTimer();
-        let status = "success";
-        let errorMsg;
-        try {
-            const result = await handler(params);
-            // Detect error responses
-            const resultObj = result;
-            if (resultObj?.isError === true) {
-                status = "error";
-                const content = resultObj?.content;
-                if (content?.[0]?.text) {
-                    try {
-                        const parsed = JSON.parse(content[0].text);
-                        errorMsg = parsed.message;
-                    }
-                    catch { /* not JSON */ }
-                }
-            }
-            return result;
-        }
-        catch (err) {
-            status = "error";
-            errorMsg = err instanceof Error ? err.message : String(err);
-            throw err;
-        }
-        finally {
-            // Fire-and-forget audit log
-            const entry = {
-                tool_name: toolName,
-                params: params,
-                status,
-                duration_ms: elapsed(),
-                error_msg: errorMsg,
-                project_id: params.project_id,
-                session_id: SESSION_ID,
-                client_name: CLIENT_NAME,
-            };
-            try {
-                const client = await getClient();
-                logAudit(client, userId, entry);
-            }
-            catch { /* non-fatal */ }
-        }
-    };
-}
-/** Expose session ID for change_history writes */
-export function getMcpSessionId() {
-    return SESSION_ID;
-}
-// ---------------------------------------------------------------------------
-// Tool Registration — Entry Point
-// ---------------------------------------------------------------------------
-server.registerTool("atoms_list_projects", {
-    title: "List ATOMS Projects",
-    description: `List all projects the authenticated user has access to.
-
-This is the ENTRY POINT tool. Call this first to discover project IDs,
-then use those IDs with all other tools.
-
-Args: None
-
-Returns:
-  { status: "success", data: [{ id, name, description, org_id, created_at }] }
-
-Examples:
-  - "What projects do I have?" → atoms_list_projects()
-  - "Show my projects" → atoms_list_projects()
-
-Workflow:
-  atoms_list_projects → atoms_list_items(project_id) → atoms_get_item(project_id, item_id)`,
-    inputSchema: {},
-    annotations: {
-        readOnlyHint: true,
-        destructiveHint: false,
-        idempotentHint: true,
-        openWorldHint: false,
-    },
-}, withMiddleware("atoms_list_projects", async () => {
-    const { listProjectsHandler } = await import("./tools/list-projects.js");
-    return listProjectsHandler();
-}));
-// ---------------------------------------------------------------------------
-// Tool Registration — Phase 2 (Read Tools)
-// ---------------------------------------------------------------------------
-server.registerTool("atoms_list_items", {
-    title: "List ATOMS Items",
-    description: `List items in an ATOMS project with optional type/domain/level filters.
-
-This is the primary ENTRY POINT for discovering items. Use it to browse
-project contents before drilling into specific items with atoms_get_item.
-
-Args:
-  - project_id (string, UUID): The project to list items from
-  - type (string, optional): Filter: requirement|test-case|note|table
-  - domain (string, optional): Filter by domain tag
-  - level (string, optional): Filter by level (System, Subsystem, Component)
-  - limit (number, optional): Max results, 1-200 (default 50)
-  - offset (number, optional): Pagination offset (default 0)
-
-Returns:
-  { status: "success", data: [{ id, title, type, status, domains, level }], meta: { total_count, limit, offset, has_more } }
-
-Examples:
-  - "Show me all requirements" → atoms_list_items(project_id, type="requirement")
-  - "What test cases exist?" → atoms_list_items(project_id, type="test-case")
-
-Errors:
-  - "Project not found" → verify project_id
-  - "Access denied" → check org membership`,
-    inputSchema: {
-        project_id: z.string().uuid("Must be a valid project UUID")
-            .describe("UUID of the project"),
-        type: z.enum(["requirement", "test-case", "note", "table"]).optional()
-            .describe("Filter by item type"),
-        domain: z.string().optional()
-            .describe("Filter by domain tag (e.g., 'Safety', 'Performance')"),
-        level: z.string().optional()
-            .describe("Filter by level (System, Subsystem, Component)"),
-        limit: z.number().int().min(1).max(200).default(50)
-            .describe("Max results (default 50, max 200)"),
-        offset: z.number().int().min(0).default(0)
-            .describe("Pagination offset (default 0)"),
-    },
-    annotations: {
-        readOnlyHint: true,
-        destructiveHint: false,
-        idempotentHint: true,
-        openWorldHint: false,
-    },
-}, withMiddleware("atoms_list_items", async (params) => {
-    const { listItemsHandler } = await import("./tools/list-items.js");
-    return listItemsHandler(params);
-}));
-server.registerTool("atoms_get_item", {
-    title: "Get ATOMS Item Details",
-    description: `Get full details of a single item including relationships, test history, and ownership.
-
-Use after atoms_list_items or atoms_search to drill into a specific item.
-
-Args:
-  - project_id (string, UUID): The project containing the item
-  - item_id (string): Item ID (e.g., "REQ-00001", "TC-00050")
-
-Returns:
-  Full WorkItem with relationships, test runs, ownership, metadata.
-
-Examples:
-  - "Show me requirement REQ-00001" → atoms_get_item(project_id, "REQ-00001")
-  - "Get test case details" → atoms_get_item(project_id, "TC-00050")`,
-    inputSchema: {
-        project_id: z.string().uuid().describe("UUID of the project"),
-        item_id: z.string().min(1).max(20).describe("Item ID (e.g., REQ-00001)"),
-    },
-    annotations: {
-        readOnlyHint: true,
-        destructiveHint: false,
-        idempotentHint: true,
-        openWorldHint: false,
-    },
-}, withMiddleware("atoms_get_item", async (params) => {
-    const { getItemHandler } = await import("./tools/get-item.js");
-    return getItemHandler(params);
-}));
-server.registerTool("atoms_search", {
-    title: "Search ATOMS Items",
-    description: `Full-text search across items in a project. Searches title, body, and summary.
-
-Alternative entry point to atoms_list_items when you know what you're looking for.
-
-Args:
-  - project_id (string, UUID): The project to search in
-  - query (string): Search text (max 1000 chars)
-  - type (string, optional): Filter by type
-  - limit (number, optional): Max results, 1-100 (default 25)
-
-Returns:
-  Matching items with @basic fields, ranked by relevance.
-
-Examples:
-  - "Find braking requirements" → atoms_search(project_id, "braking system")
-  - "Search for safety tests" → atoms_search(project_id, "safety", type="test-case")`,
-    inputSchema: {
-        project_id: z.string().uuid().describe("UUID of the project"),
-        query: z.string().min(1).max(1000).describe("Search text"),
-        type: z.enum(["requirement", "test-case", "note", "table"]).optional()
-            .describe("Filter by item type"),
-        limit: z.number().int().min(1).max(100).default(25)
-            .describe("Max results (default 25, max 100)"),
-    },
-    annotations: {
-        readOnlyHint: true,
-        destructiveHint: false,
-        idempotentHint: true,
-        openWorldHint: false,
-    },
-}, withMiddleware("atoms_search", async (params) => {
-    const { searchHandler } = await import("./tools/search.js");
-    return searchHandler(params);
-}));
-// MCP App: Coverage Heatmap — renders coverage visualization in UI-capable hosts
-registerAtomsApp(server, {
-    appName: "coverage",
-    htmlFile: "coverage-app.html",
-    toolName: "atoms_get_coverage",
-    title: "Get Test Coverage Report",
-    description: `Find requirements without linked test cases (coverage gaps).
-
-Essential for compliance reporting in safety-critical industries.
-
-In MCP App hosts (Claude, ChatGPT), renders a visual coverage heatmap.
-Falls back to JSON for non-UI clients.
-
-Args:
-  - project_id (string, UUID): The project to analyze
-  - domain (string, optional): Filter by domain
-  - level (string, optional): Filter by level
-
-Returns:
-  { covered, uncovered, total, coverage_percent, uncovered_items: [...] }
-
-Examples:
-  - "What's our test coverage?" → atoms_get_coverage(project_id)
-  - "Safety coverage gaps?" → atoms_get_coverage(project_id, domain="Safety")`,
-    inputSchema: {
-        project_id: z.string().uuid().describe("UUID of the project"),
-        domain: z.string().optional().describe("Filter by domain tag"),
-        level: z.string().optional().describe("Filter by level"),
-    },
-    annotations: {
-        readOnlyHint: true,
-        destructiveHint: false,
-        idempotentHint: true,
-        openWorldHint: false,
-    },
-    handler: withMiddleware("atoms_get_coverage", async (params) => {
-        const { getCoverageHandler } = await import("./tools/get-coverage.js");
-        return getCoverageHandler(params);
-    }),
-});
-server.registerTool("atoms_get_history", {
-    title: "Get Item Change History",
-    description: `Audit trail for an item — who changed what, when, and whether it was human or AI.
-
-Shows actor attribution (user vs mcp_claude) and session grouping.
-
-Args:
-  - project_id (string, UUID): The project containing the item
-  - item_id (string): Item ID
-  - limit (number, optional): Max entries (default 20, max 100)
-
-Returns:
-  Change entries with actor, session_id, event_type, changed_at, fields_changed.`,
-    inputSchema: {
-        project_id: z.string().uuid().describe("UUID of the project"),
-        item_id: z.string().min(1).max(20).describe("Item ID"),
-        limit: z.number().int().min(1).max(100).default(20)
-            .describe("Max entries (default 20)"),
-    },
-    annotations: {
-        readOnlyHint: true,
-        destructiveHint: false,
-        idempotentHint: true,
-        openWorldHint: false,
-    },
-}, withMiddleware("atoms_get_history", async (params) => {
-    const { getHistoryHandler } = await import("./tools/get-history.js");
-    return getHistoryHandler(params);
-}));
-// MCP App: Mermaid Diagram — renders interactive diagram in UI-capable hosts
-registerAtomsApp(server, {
-    appName: "mermaid",
-    htmlFile: "mermaid-app.html",
-    toolName: "atoms_export_mermaid",
-    title: "Export Mermaid Diagram",
-    description: `Generate a Mermaid diagram of the requirement/test hierarchy.
-
-Output is paste-ready for markdown docs. Shows parent-child relationships
-and requirement-to-test-case verification links.
-
-In MCP App hosts (Claude, ChatGPT), renders an interactive pan/zoom diagram.
-Falls back to Mermaid text for non-UI clients.
-
-Args:
-  - project_id (string, UUID): The project to visualize
-  - root_item_id (string, optional): Start node (default: all roots)
-  - depth (number, optional): Max depth (default 3, max 10)
-  - include_tests (boolean, optional): Show test case links (default true)
-
-Returns:
-  Mermaid graph string.`,
-    inputSchema: {
-        project_id: z.string().uuid().describe("UUID of the project"),
-        root_item_id: z.string().optional().describe("Root item ID to start from"),
-        depth: z.number().int().min(1).max(10).default(3).describe("Max depth"),
-        include_tests: z.boolean().default(true).describe("Include test case links"),
-    },
-    annotations: {
-        readOnlyHint: true,
-        destructiveHint: false,
-        idempotentHint: true,
-        openWorldHint: false,
-    },
-    extraResourceDomains: ["cdn.jsdelivr.net"],
-    handler: withMiddleware("atoms_export_mermaid", async (params) => {
-        const { exportMermaidHandler } = await import("./tools/export-mermaid.js");
-        return exportMermaidHandler(params);
-    }),
-});
-// ---------------------------------------------------------------------------
-// Tool Registration — Phase 3 (Write Tools)
-// ---------------------------------------------------------------------------
-server.registerTool("atoms_create_item", {
-    title: "Create ATOMS Item",
-    description: `Create a new requirement, test case, or note in a project.
-
-Requires editor or admin role. Changes are logged with AI actor attribution.
-
-Args:
-  - project_id (string, UUID): Target project
-  - type (string): requirement|test-case|note
-  - title (string): Item title (max 500 chars)
-  - body (string, optional): Rich text body
-  - summary (string, optional): Brief summary
-  - domains (string[], optional): Domain tags
-  - level (string, optional): System|Subsystem|Component
-  - parent_ids (string[], optional): Parent item IDs to link
-
-Returns:
-  Created item with generated ID (e.g., "REQ-00058")
-
-Side effects:
-  - Logs to change_history with actor='mcp_claude'
-  - Creates relationships if parent_ids provided`,
-    inputSchema: {
-        project_id: z.string().uuid().describe("UUID of the target project"),
-        type: z.enum(["requirement", "test-case", "note"]).describe("Item type"),
-        title: z.string().min(1).max(500).describe("Item title"),
-        body: z.string().optional().describe("Rich text body"),
-        summary: z.string().optional().describe("Brief summary"),
-        domains: z.array(z.string()).optional().describe("Domain tags"),
-        level: z.string().optional().describe("System|Subsystem|Component"),
-        parent_ids: z.array(z.string()).optional().describe("Parent item IDs to link"),
-    },
-    annotations: {
-        readOnlyHint: false,
-        destructiveHint: false,
-        idempotentHint: false,
-        openWorldHint: false,
-    },
-}, withMiddleware("atoms_create_item", async (params) => {
-    const { createItemHandler } = await import("./tools/create-item.js");
-    return createItemHandler(params);
-}));
-server.registerTool("atoms_update_item", {
-    title: "Update ATOMS Item",
-    description: `Update an existing item's fields. Only provided fields are changed.
-
-Requires editor or admin role. Logs old/new data diff to change history.
-
-Args:
-  - project_id (string, UUID): Project containing the item
-  - item_id (string): Item to update
-  - title, body, summary, domains, level, status: Fields to update (all optional)
-
-Returns:
-  Updated item.`,
-    inputSchema: {
-        project_id: z.string().uuid().describe("UUID of the project"),
-        item_id: z.string().min(1).max(20).describe("Item ID to update"),
-        title: z.string().min(1).max(500).optional().describe("New title"),
-        body: z.string().optional().describe("New body"),
-        summary: z.string().optional().describe("New summary"),
-        domains: z.array(z.string()).optional().describe("New domain tags"),
-        level: z.string().optional().describe("New level"),
-        status: z.enum(["passed", "failed", "blocked", "not-run"]).optional()
-            .describe("Test case status"),
-    },
-    annotations: {
-        readOnlyHint: false,
-        destructiveHint: false,
-        idempotentHint: true,
-        openWorldHint: false,
-    },
-}, withMiddleware("atoms_update_item", async (params) => {
-    const { updateItemHandler } = await import("./tools/update-item.js");
-    return updateItemHandler(params);
-}));
-server.registerTool("atoms_delete_item", {
-    title: "Delete ATOMS Item",
-    description: `Soft-delete an item (sets deleted_at, preserves for audit trail).
-
-Requires editor or admin role. The item is never truly removed.
-
-Args:
-  - project_id (string, UUID): Project containing the item
-  - item_id (string): Item to delete
-
-Returns:
-  Confirmation with deleted item summary.`,
-    inputSchema: {
-        project_id: z.string().uuid().describe("UUID of the project"),
-        item_id: z.string().min(1).max(20).describe("Item ID to soft-delete"),
-    },
-    annotations: {
-        readOnlyHint: false,
-        destructiveHint: true,
-        idempotentHint: true,
-        openWorldHint: false,
-    },
-}, withMiddleware("atoms_delete_item", async (params) => {
-    const { deleteItemHandler } = await import("./tools/delete-item.js");
-    return deleteItemHandler(params);
-}));
-server.registerTool("atoms_link_items", {
-    title: "Link ATOMS Items",
-    description: `Add or remove relationships between items.
-
-Supports: parent, child, related, verifies, verified_by.
-Updates both items' JSONB data and the shadow table.
-
-Args:
-  - project_id (string, UUID): Project containing both items
-  - from_id (string): Source item
-  - to_id (string): Target item
-  - type (string): parent|child|related|verifies|verified_by
-  - action (string): add|remove
-
-Returns:
-  Updated relationship state for both items.`,
-    inputSchema: {
-        project_id: z.string().uuid().describe("UUID of the project"),
-        from_id: z.string().min(1).max(20).describe("Source item ID"),
-        to_id: z.string().min(1).max(20).describe("Target item ID"),
-        type: z.enum(["parent", "child", "related", "verifies", "verified_by"])
-            .describe("Relationship type"),
-        action: z.enum(["add", "remove"]).describe("Add or remove the relationship"),
-    },
-    annotations: {
-        readOnlyHint: false,
-        destructiveHint: false,
-        idempotentHint: true,
-        openWorldHint: false,
-    },
-}, withMiddleware("atoms_link_items", async (params) => {
-    const { linkItemsHandler } = await import("./tools/link-items.js");
-    return linkItemsHandler(params);
-}));
-// MCP App: Bulk Import — renders import results table in UI-capable hosts
-registerAtomsApp(server, {
-    appName: "import",
-    htmlFile: "import-app.html",
-    toolName: "atoms_bulk_import",
-    title: "Bulk Import ATOMS Items",
-    description: `Bulk create multiple items in a single tool call. Essential for AI agents
-that generate 20+ requirements at once.
-
-Checks write access once, generates sequential IDs, batch inserts all items,
-and reports per-item errors without aborting the entire batch.
-
-In MCP App hosts (Claude, ChatGPT), renders an interactive results table.
-Falls back to JSON for non-UI clients.
-
-Args:
-  - project_id (string, UUID): Target project
-  - items (array): Up to 100 items to create, each with:
-    - type (string): requirement|test-case|note
-    - title (string): Item title (max 500 chars)
-    - body (string, optional): Rich text body
-    - summary (string, optional): Brief summary
-    - domains (string[], optional): Domain tags
-    - level (string, optional): System|Subsystem|Component
-    - parent_id (string, optional): Parent item ID to link
-
-Returns:
-  { created: number, items: [{ id, title, type }], errors: [] }
-
-Limits:
-  - Maximum 100 items per call
-  - If any item fails, others still succeed — errors reported separately
-
-Side effects:
-  - Logs to change_history with actor='mcp_claude' for each created item
-  - Creates parent relationships for items with parent_id`,
-    inputSchema: {
-        project_id: z.string().uuid().describe("UUID of the target project"),
-        items: z.array(z.object({
-            type: z.enum(["requirement", "test-case", "note"]).describe("Item type"),
-            title: z.string().min(1).max(500).describe("Item title"),
-            body: z.string().optional().describe("Rich text body"),
-            summary: z.string().optional().describe("Brief summary"),
-            domains: z.array(z.string()).optional().describe("Domain tags"),
-            level: z.string().optional().describe("System|Subsystem|Component"),
-            parent_id: z.string().optional().describe("Parent item ID to link"),
-        })).min(1).max(100).describe("Items to create (1-100)"),
-    },
-    annotations: {
-        readOnlyHint: false,
-        destructiveHint: false,
-        idempotentHint: false,
-        openWorldHint: false,
-    },
-    handler: withMiddleware("atoms_bulk_import", async (params) => {
-        const { bulkImportHandler } = await import("./tools/bulk-import.js");
-        return bulkImportHandler(params);
-    }),
-});
-server.registerTool("atoms_record_test_result", {
-    title: "Record Test Result",
-    description: `Record a pass/fail/blocked result for a test case.
-
-Appends to the test results history. Use atoms_get_item to see all results.
-
-Args:
-  - project_id (string, UUID): Project containing the test case
-  - item_id (string): Test case ID (e.g., "TC-00001")
-  - result (string): passed|failed|blocked|not-run
-  - note (string, optional): Reason or comment for this result
-
-Returns:
-  Recorded result with timestamp.
-
-Side effects:
-  - Appends to test_results table
-  - Logs to change_history with actor='mcp_claude'`,
-    inputSchema: {
-        project_id: z.string().uuid().describe("UUID of the project"),
-        item_id: z.string().min(1).max(20).describe("Test case ID (e.g., TC-00001)"),
-        result: z.enum(["passed", "failed", "blocked", "not-run"])
-            .describe("Test result"),
-        note: z.string().max(1000).optional()
-            .describe("Reason or comment for this result"),
-    },
-    annotations: {
-        readOnlyHint: false,
-        destructiveHint: false,
-        idempotentHint: false,
-        openWorldHint: false,
-    },
-}, withMiddleware("atoms_record_test_result", async (params) => {
-    const { recordTestResultHandler } = await import("./tools/record-test-result.js");
-    return recordTestResultHandler(params);
-}));
-// ---------------------------------------------------------------------------
-// Tool Registration — Phase 4 (Advanced Tools)
-// ---------------------------------------------------------------------------
-// MCP App: Trace Graph — renders interactive force-directed graph in UI-capable hosts
-registerAtomsApp(server, {
-    appName: "trace",
-    htmlFile: "trace-app.html",
-    toolName: "atoms_trace",
-    title: "Trace Item Relationships",
-    description: `Walk the traceability graph from a starting item.
-
-Answers questions like "which requirements does TC-00003 verify?" or
-"if I change REQ-00001, what's affected downstream?"
-
-In MCP App hosts (Claude, ChatGPT), renders an interactive graph visualization.
-Falls back to flat list for non-UI clients.
-
-Args:
-  - project_id (string, UUID): Project containing the item
-  - item_id (string): Starting item ID
-  - direction (string): upstream|downstream|both
-    - upstream: follow parent/verifies links (dependencies)
-    - downstream: follow child/verified_by links (dependents)
-    - both: trace in both directions
-  - depth (number, optional): Max traversal depth (default 5, max 10)
-  - relationship_types (string[], optional): Filter to specific types (parent, child, related, verifies, verified_by)
-
-Returns:
-  { root, direction, items: [{ id, title, type, relationship, depth }], total_count }
-
-Examples:
-  - "What does TC-00003 verify?" → atoms_trace(project_id, "TC-00003", "upstream")
-  - "What's affected by REQ-00001?" → atoms_trace(project_id, "REQ-00001", "downstream")`,
-    inputSchema: {
-        project_id: z.string().uuid().describe("UUID of the project"),
-        item_id: z.string().min(1).max(20).describe("Starting item ID"),
-        direction: z.enum(["upstream", "downstream", "both"])
-            .describe("Traversal direction"),
-        depth: z.number().int().min(1).max(10).default(5)
-            .describe("Max traversal depth (default 5)"),
-        relationship_types: z.array(z.enum(["parent", "child", "related", "verifies", "verified_by"])).optional()
-            .describe("Filter to specific relationship types"),
-    },
-    annotations: {
-        readOnlyHint: true,
-        destructiveHint: false,
-        idempotentHint: true,
-        openWorldHint: false,
-    },
-    handler: withMiddleware("atoms_trace", async (params) => {
-        const { traceHandler } = await import("./tools/trace.js");
-        return traceHandler(params);
-    }),
-});
-// MCP App: Project Summary Dashboard — renders interactive compliance dashboard in UI-capable hosts
-registerAtomsApp(server, {
-    appName: "summary",
-    htmlFile: "summary-app.html",
-    toolName: "atoms_project_summary",
-    title: "Project Compliance Summary",
-    description: `One-call project health and compliance dashboard.
-
-Returns item counts by type, test execution status, requirement coverage
-(overall and by domain), and recent change activity.
-
-In MCP App hosts (Claude, ChatGPT), renders an interactive dashboard with charts.
-Falls back to JSON for non-UI clients.
-
-Args:
-  - project_id (string, UUID): Project to summarize
-
-Returns:
-  { project_name, counts, test_status, coverage, coverage_by_domain, recent_changes, last_updated }
-
-Examples:
-  - "Give me a compliance snapshot" → atoms_project_summary(project_id)
-  - "How's our test coverage?" → atoms_project_summary(project_id)`,
-    inputSchema: {
-        project_id: z.string().uuid().describe("UUID of the project"),
-    },
-    annotations: {
-        readOnlyHint: true,
-        destructiveHint: false,
-        idempotentHint: true,
-        openWorldHint: false,
-    },
-    handler: withMiddleware("atoms_project_summary", async (params) => {
-        const { projectSummaryHandler } = await import("./tools/project-summary.js");
-        return projectSummaryHandler(params);
-    }),
-});