gasp-standard-mcp 1.0.1 → 1.2.1

package/README.md

@@ -37,13 +37,15 @@ Restart your MCP client after adding the config.
 | `list_metrics` | List all metrics, optionally filtered by department |
 | `get_formula` | Get formula(s) for a metric |
 | `get_relationships` | Upstream and downstream metric relationships |
-| `search` | Full-text search across all metrics and definitions |
+| `get_data_requirements` | Data requirements for implementing a metric: fields, types, grain, source, and example SQL |
+| `search` | Full-text search across metrics, definitions, and data requirements |
 
 ## Data
 
 - 299 metrics across 13 departments
 - 79 glossary definitions
-- 21 relationship nodes, 25 edges
+- 22 relationship nodes, 34 edges
+- 75 data requirements with field types, grain, and example SQL
 - Sources: the canonical [GASP Standard](https://gaspwiki.com) files
 
 ## Examples
@@ -54,6 +56,7 @@ Once installed, ask your AI assistant:
 - "How do I calculate CAC Payback?"
 - "What drives ARR?"
 - "List all marketing metrics"
+- "What data do I need to implement ARR tracking?"
 - "Search for churn"
 
 ## License

package/build/export-data.js

@@ -15,6 +15,7 @@ const version = {
     definitionCount: data.definitions.length,
     nodeCount: data.nodes.length,
     edgeCount: data.edges.length,
+    dataRequirementCount: data.dataRequirements.length,
     buildDate: new Date().toISOString().slice(0, 10),
 };
 const versionJson = JSON.stringify(version);
@@ -27,6 +28,11 @@ writeFileSync(join(webOutDir, "standard-version.json"), versionJson);
 const buildDir = new URL(".", import.meta.url).pathname;
 writeFileSync(join(buildDir, "standard-data.json"), json);
 writeFileSync(join(buildDir, "standard-version.json"), versionJson);
-console.log(`Exported ${data.metrics.length} metrics, ${data.definitions.length} definitions, ${data.nodes.length} nodes, ${data.edges.length} edges (${version.buildDate})`);
+// 3. Write to website/src/data/ → importable by React components
+const srcDataDir = join(new URL(".", import.meta.url).pathname, "..", "..", "website", "src", "data");
+mkdirSync(srcDataDir, { recursive: true });
+writeFileSync(join(srcDataDir, "standard.json"), json);
+console.log(`Exported ${data.metrics.length} metrics, ${data.definitions.length} definitions, ${data.nodes.length} nodes, ${data.edges.length} edges, ${data.dataRequirements.length} data requirements (${version.buildDate})`);
 console.log(`  → website/public/api/standard.json + standard-version.json`);
 console.log(`  → mcp-server/build/standard-data.json + standard-version.json`);
+console.log(`  → website/src/data/standard.json`);

package/build/index.js

@@ -59,10 +59,15 @@ server.tool("lookup_metric", "Look up a GASP Standard metric by name or abbrevia
         };
     }
     // Build response with branding swap
+    const signalLabel = metric.signalType.charAt(0).toUpperCase() + metric.signalType.slice(1);
+    const signalLine = metric.signalTypeSecondary
+        ? `**Signal Type:** ${signalLabel} (+ ${metric.signalTypeSecondary.charAt(0).toUpperCase() + metric.signalTypeSecondary.slice(1)})`
+        : `**Signal Type:** ${signalLabel}`;
     const parts = [
         `# ${metric.name}`,
         `**Department:** ${metric.department}`,
         `**Category:** ${metric.category}`,
+        signalLine,
     ];
     if (metric.definition) {
         parts.push(`\n**Definition:** ${metric.definition}`);
@@ -94,16 +99,23 @@ server.tool("lookup_metric", "Look up a GASP Standard metric by name or abbrevia
     return { content: [{ type: "text", text }] };
 });
 // --- Tool 2: list_metrics ---
-server.tool("list_metrics", "List all GASP Standard metrics, optionally filtered by department. Returns metric names grouped by category.", {
+server.tool("list_metrics", "List all GASP Standard metrics, optionally filtered by department and/or signal type. Returns metric names grouped by category.", {
     department: z
         .string()
         .optional()
         .describe("Filter by department name (e.g. 'sales', 'marketing', 'core'). Case-insensitive. Omit to list all."),
-}, async ({ department }) => {
+    signalType: z
+        .enum(["outcome", "leading", "efficiency", "operational"])
+        .optional()
+        .describe("Filter by signal type. Returns metrics where primary or secondary type matches."),
+}, async ({ department, signalType }) => {
     let filtered = data.metrics;
     if (department) {
         const q = department.toLowerCase();
-        filtered = data.metrics.filter((m) => m.department.toLowerCase().includes(q));
+        filtered = filtered.filter((m) => m.department.toLowerCase().includes(q));
+    }
+    if (signalType) {
+        filtered = filtered.filter((m) => m.signalType === signalType || m.signalTypeSecondary === signalType);
     }
     if (filtered.length === 0) {
         const departments = [
@@ -218,7 +230,76 @@ server.tool("get_relationships", "Get the upstream (what drives it) and downstre
     }
     return { content: [{ type: "text", text: parts.join("\n") }] };
 });
-// --- Tool 5: search ---
+// --- Tool 5: get_data_requirements ---
+server.tool("get_data_requirements", "Get the data requirements for implementing a GASP Standard metric or department dashboard. Returns required fields with types, reporting grain, source system, and example SQL query.", {
+    metric: z
+        .string()
+        .optional()
+        .describe("Metric name to search for (e.g. 'ARR', 'Pipeline', 'CSAT')"),
+    department: z
+        .string()
+        .optional()
+        .describe("Department name (e.g. 'Sales', 'Engineering', 'Executive'). Omit to search all."),
+}, async ({ metric, department }) => {
+    let filtered = data.dataRequirements || [];
+    if (department) {
+        const q = department.toLowerCase();
+        filtered = filtered.filter((dr) => dr.department.toLowerCase().includes(q));
+    }
+    if (metric) {
+        const q = metric.toLowerCase();
+        filtered = filtered.filter((dr) => dr.metric.toLowerCase() === q ||
+            dr.metric.toLowerCase().includes(q) ||
+            dr.fields.some((f) => f.toLowerCase().includes(q)));
+    }
+    if (filtered.length === 0) {
+        const depts = [
+            ...new Set((data.dataRequirements || []).map((dr) => dr.department)),
+        ].sort();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `No data requirements found${metric ? ` for metric "${metric}"` : ""}${department ? ` in department "${department}"` : ""}.\n\nAvailable departments: ${depts.join(", ")}`,
+                },
+            ],
+        };
+    }
+    const parts = [
+        `# Data Requirements (${filtered.length} entries)\n`,
+    ];
+    // Group by department
+    const grouped = new Map();
+    for (const dr of filtered) {
+        if (!grouped.has(dr.department))
+            grouped.set(dr.department, []);
+        grouped.get(dr.department).push(dr);
+    }
+    for (const [dept, drs] of grouped) {
+        parts.push(`## ${dept}\n`);
+        for (const dr of drs) {
+            parts.push(`### ${dr.metric}`);
+            parts.push(`- **Source:** ${dr.source}`);
+            parts.push(`- **Grain:** ${dr.grain}`);
+            parts.push(`- **Frequency:** ${dr.frequency}`);
+            parts.push(`- **Description:** ${dr.description}`);
+            parts.push("");
+            // Field table
+            parts.push("| Field | Type |");
+            parts.push("|-------|------|");
+            for (const field of dr.fields) {
+                const fieldType = dr.fieldTypes?.[field] || "unknown";
+                parts.push(`| \`${field}\` | ${fieldType} |`);
+            }
+            parts.push("");
+            // SQL
+            parts.push("**Example SQL:**");
+            parts.push("```sql\n" + dr.exampleQuery + "\n```\n");
+        }
+    }
+    return { content: [{ type: "text", text: parts.join("\n") }] };
+});
+// --- Tool 6: search ---
 server.tool("search", "Search across all GASP Standard metrics and definitions. Returns top 10 matches ranked by relevance.", { query: z.string().describe("Search query (e.g. 'churn', 'retention', 'pipeline coverage')") }, async ({ query: q }) => {
     const results = search(data, q, 10);
     if (results.length === 0) {

package/build/loader.d.ts

@@ -10,7 +10,7 @@ export declare function loadStandard(): StandardData;
  * Returns top N matches ranked by relevance.
  */
 export declare function search(data: StandardData, query: string, limit?: number): Array<{
-    type: "metric" | "definition";
+    type: "metric" | "definition" | "data_requirement";
     name: string;
     snippet: string;
     department?: string;

package/build/loader.js

@@ -42,7 +42,62 @@ export function loadStandard() {
     const relData = JSON.parse(readFileSync(relPath, "utf-8"));
     const nodes = relData.nodes;
     const edges = relData.edges;
-    return { metrics, definitions, nodes, edges };
+    // Load data requirements from dashboard
+    const dashPath = join(root, "website", "src", "data", "dashboard-mock.json");
+    const dashData = JSON.parse(readFileSync(dashPath, "utf-8"));
+    const dataRequirements = [];
+    for (const dr of dashData.dataRequirements || []) {
+        dataRequirements.push({ ...dr, department: "Executive" });
+    }
+    for (const [, dept] of Object.entries(dashData.departments || {})) {
+        const d = dept;
+        for (const dr of d.dataRequirements || []) {
+            dataRequirements.push({ ...dr, department: d.name });
+        }
+    }
+    // Load taxonomy classifications
+    const taxonomyPath = join(standardDir, "taxonomy.json");
+    let taxonomy = { classifications: {} };
+    try {
+        taxonomy = JSON.parse(readFileSync(taxonomyPath, "utf-8"));
+    }
+    catch {
+        // taxonomy.json not yet created — default to operational
+    }
+    // Merge signal types into metrics
+    for (const m of metrics) {
+        const deptSlug = m.department.toLowerCase().replace(/\s+/g, "-");
+        const key = `${deptSlug}::${m.slug}`;
+        const entry = taxonomy.classifications[key];
+        if (entry) {
+            m.signalType = entry.primary;
+            m.signalTypeSecondary = entry.secondary || null;
+        }
+        else {
+            // Cross-reference stubs: look up canonical metric's classification
+            const seeMatch = m.rawMarkdown.match(/See \[([^\]]+)\]\(([^)]+)\)/);
+            if (seeMatch) {
+                const link = seeMatch[2];
+                const anchor = link.includes("#") ? link.split("#")[1] : null;
+                if (anchor) {
+                    // Find canonical metric's key
+                    for (const [canonKey, canonEntry] of Object.entries(taxonomy.classifications)) {
+                        if (canonKey.endsWith(`::${anchor}`)) {
+                            m.signalType = canonEntry.primary;
+                            m.signalTypeSecondary = canonEntry.secondary || null;
+                            break;
+                        }
+                    }
+                }
+            }
+            // Fallback if still unset
+            if (!m.signalType) {
+                m.signalType = "operational";
+                m.signalTypeSecondary = null;
+            }
+        }
+    }
+    return { metrics, definitions, nodes, edges, dataRequirements };
 }
 /**
  * Search metrics + definitions for a query string.
@@ -54,10 +109,11 @@ export function search(data, query, limit = 10) {
     for (const m of data.metrics) {
         const score = scoreMetric(m, q);
         if (score > 0) {
+            const signalLabel = m.signalType.charAt(0).toUpperCase() + m.signalType.slice(1);
             results.push({
                 type: "metric",
                 name: m.name,
-                snippet: m.definition || m.insight || "",
+                snippet: `[${signalLabel}] ${m.definition || m.insight || ""}`,
                 department: m.department,
                 score,
             });
@@ -74,6 +130,28 @@ export function search(data, query, limit = 10) {
             });
         }
     }
+    for (const dr of data.dataRequirements || []) {
+        let score = 0;
+        if (dr.metric.toLowerCase() === q)
+            score += 70;
+        else if (dr.metric.toLowerCase().includes(q))
+            score += 35;
+        if (dr.description.toLowerCase().includes(q))
+            score += 10;
+        if (dr.fields.some((f) => f.toLowerCase().includes(q)))
+            score += 15;
+        if (dr.department.toLowerCase().includes(q))
+            score += 5;
+        if (score > 0) {
+            results.push({
+                type: "data_requirement",
+                name: dr.metric,
+                snippet: `[${dr.department}] ${dr.description} (grain: ${dr.grain})`,
+                department: dr.department,
+                score,
+            });
+        }
+    }
     results.sort((a, b) => b.score - a.score);
     return results.slice(0, limit).map(({ score: _, ...rest }) => rest);
 }

package/build/parser.js

@@ -145,6 +145,8 @@ function parseSectionFields(name, slug, raw, department, category, aliases) {
         category,
         aliases,
         rawMarkdown: `### ${name}\n\n${raw}`,
+        signalType: "operational",
+        signalTypeSecondary: null,
     };
 }
 /** Extract a **FieldName:** value from markdown */