@sampuli/mcp 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sampuli/mcp",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Model Context Protocol server for Sampuli — generate format-true synthetic test data for 90 countries directly inside Claude, Cursor, Copilot and any MCP client.",
   "type": "module",
   "main": "./src/server.js",
@@ -44,7 +44,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "@sampuli/data": "^0.3.0",
+    "@sampuli/data": "^0.3.3",
     "zod": "^3.25.0"
   },
   "devDependencies": {

package/src/server.js

@@ -3,7 +3,7 @@
 // generate format-true test data inline. Transport is stdio (see bin.js).
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 import { z } from 'zod'
-import { listCountries, describeCountry, generateData } from './tools.js'
+import { listCountries, describeCountry, generateData, listGenericTypes, generateFromSchema } from './tools.js'
 
 export function createServer() {
   const server = new McpServer({
@@ -40,7 +40,7 @@ export function createServer() {
       description:
         'Generate format-true, entirely synthetic test data for a country. spec is "<country>.<selector>" where selector is a field key ("phone"), "person" (a full coherent record), or "preset:<key>" (a scenario). Values match each country\'s real formats and pass validators (IBAN mod-97, card Luhn, …) but are never real or registered.',
       inputSchema: {
-        spec: z.string().describe('e.g. "ke.person", "de.iban", "ng.phone", "ke.preset:kyc".'),
+        spec: z.string().describe('e.g. "ke.person" (core fields), "ke.full" (every field incl. card/passport/income), "de.iban", "ng.phone", "ke.company", "ke.product", "ke.preset:kyc".'),
         count: z.number().int().min(1).max(10000).optional().describe('How many rows (omit for one).'),
         fields: z.union([z.array(z.string()), z.literal('all')]).optional().describe('Which fields for a person record, or "all".'),
         seed: z.string().optional().describe('Reproducible output — same seed, same data.'),
@@ -50,5 +50,35 @@ export function createServer() {
     async args => generateData(args),
   )
 
+  server.registerTool(
+    'sampuli_list_types',
+    {
+      title: 'List generic field types',
+      description: 'List the country-agnostic generic types (uuid, enum, int, float, date, vin, isbn, imei, mac, email, …) usable in a custom schema or as "any.<type>".',
+      inputSchema: {},
+    },
+    async () => listGenericTypes(),
+  )
+
+  server.registerTool(
+    'sampuli_schema',
+    {
+      title: 'Generate a custom dataset',
+      description:
+        'Generate rows from a custom schema, mixing generic types and country-accurate fields. Each field has a name and a type — a generic type ("uuid", "int:0,500", "enum:free,pro,team", "date:2021,2025") or a country field spec ("ke.phone", "de.iban"). Optional per-field "blank" (0–1) makes it null that often.',
+      inputSchema: {
+        fields: z.array(z.object({
+          name: z.string().describe('Column name.'),
+          type: z.string().describe('Generic type or country field spec, e.g. "uuid", "int:0,500", "ke.phone".'),
+          blank: z.number().min(0).max(1).optional().describe('Probability (0–1) the value is null.'),
+        })).describe('The columns to generate.'),
+        count: z.number().int().min(1).max(10000).optional().describe('How many rows (default 1).'),
+        seed: z.string().optional().describe('Reproducible output.'),
+        format: z.enum(['json', 'csv']).optional(),
+      },
+    },
+    async args => generateFromSchema(args),
+  )
+
   return server
 }

package/src/tools.js

@@ -1,7 +1,7 @@
 // Pure tool implementations for the Sampuli MCP server.
 // Kept separate from the transport so they can be unit-tested directly.
 // Each returns a Model Context Protocol tool result: { content: [...], isError? }.
-import { generate, generateMany, listPacks, listFields, listPresets } from '@sampuli/data'
+import { generate, generateMany, generateSchema, listPacks, listFields, listPresets, listTypes } from '@sampuli/data'
 
 const text = t => ({ content: [{ type: 'text', text: t }] })
 const fail = t => ({ content: [{ type: 'text', text: t }], isError: true })
@@ -64,3 +64,26 @@ export function generateData({ spec, count, fields, seed, format }) {
   if (format === 'csv') return text(toCsv(data))
   return text(typeof data === 'string' ? data : JSON.stringify(data, null, 2))
 }
+
+/** List the generic, country-agnostic field types (uuid, enum, int, vin…). */
+export function listGenericTypes() {
+  const lines = listTypes().map(t => `  ${t.key.padEnd(12)} ${t.label}${t.params ? `  (${t.params})` : ''}`)
+  return text(`Generic types — use as "any.<type>" or as a field type in a custom schema:\n${lines.join('\n')}`)
+}
+
+/**
+ * Generate rows from a custom schema — mix generic types and country fields.
+ *   fields: [{ name, type, blank? }]  type = "uuid" | "int:0,500" | "ke.phone" | …
+ *   count:  rows (default 1)
+ *   seed:   reproducible
+ *   format: "json" | "csv"
+ */
+export function generateFromSchema({ fields, count, seed, format }) {
+  if (!Array.isArray(fields) || fields.length === 0) return fail('`fields` must be a non-empty array of { name, type }.')
+  const schema = { fields, count: Number(count) || 1 }
+  if (seed != null && seed !== '') schema.seed = String(seed)
+  let rows
+  try { rows = generateSchema(schema) } catch (e) { return fail(e.message) }
+  if (format === 'csv') return text(toCsv(rows))
+  return text(JSON.stringify(rows, null, 2))
+}