@nado-language/mcp 0.1.0

package/dist/probe-nado-mcp.mjs

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const serverPath = firstExisting([
+  path.join(__dirname, 'nado-language-server.mjs'),
+  path.join(__dirname, '..', 'mcp', 'nado-language-server.mjs'),
+]);
+const mode = process.argv[2] || 'list';
+const args = process.argv.slice(3);
+
+const child = spawn(process.execPath, [serverPath], {
+  cwd: path.join(__dirname, '..'),
+  env: process.env,
+  stdio: ['pipe', 'pipe', 'inherit'],
+});
+
+function firstExisting(candidates) {
+  return candidates.find((candidate) => existsSync(candidate)) || candidates[0];
+}
+
+let buffer = Buffer.alloc(0);
+let nextId = 1;
+const pending = new Map();
+
+child.stdout.on('data', (chunk) => {
+  buffer = Buffer.concat([buffer, chunk]);
+  drain();
+});
+
+child.on('exit', (code) => {
+  if (code !== 0 && pending.size > 0) {
+    for (const { reject } of pending.values()) reject(new Error(`MCP server exited with code ${code}`));
+    pending.clear();
+  }
+});
+
+function send(method, params = {}) {
+  const id = nextId++;
+  const message = { jsonrpc: '2.0', id, method, params };
+  const payload = JSON.stringify(message);
+  child.stdin.write(`Content-Length: ${Buffer.byteLength(payload, 'utf8')}\r\n\r\n${payload}`);
+  return new Promise((resolve, reject) => pending.set(id, { resolve, reject }));
+}
+
+function notify(method, params = {}) {
+  const payload = JSON.stringify({ jsonrpc: '2.0', method, params });
+  child.stdin.write(`Content-Length: ${Buffer.byteLength(payload, 'utf8')}\r\n\r\n${payload}`);
+}
+
+function drain() {
+  while (true) {
+    const headerEnd = buffer.indexOf('\r\n\r\n');
+    if (headerEnd < 0) return;
+    const header = buffer.slice(0, headerEnd).toString('utf8');
+    const match = header.match(/content-length:\s*(\d+)/i);
+    if (!match) throw new Error(`Missing Content-Length in ${header}`);
+    const contentLength = Number(match[1]);
+    const frameEnd = headerEnd + 4 + contentLength;
+    if (buffer.length < frameEnd) return;
+    const payload = buffer.slice(headerEnd + 4, frameEnd).toString('utf8');
+    buffer = buffer.slice(frameEnd);
+
+    const message = JSON.parse(payload);
+    const request = pending.get(message.id);
+    if (!request) continue;
+    pending.delete(message.id);
+    if (message.error) request.reject(new Error(message.error.message));
+    else request.resolve(message.result);
+  }
+}
+
+try {
+  await send('initialize', {
+    protocolVersion: '2025-06-18',
+    capabilities: {},
+    clientInfo: { name: 'nado-mcp-probe', version: '0.1.0' },
+  });
+  notify('notifications/initialized');
+
+  if (mode === 'list') {
+    const result = await send('tools/list');
+    console.log(JSON.stringify(result, null, 2));
+  } else if (mode === 'whoami') {
+    const result = await send('tools/call', { name: 'nado_whoami', arguments: {} });
+    console.log(result.content?.[0]?.text || JSON.stringify(result, null, 2));
+  } else if (mode === 'save') {
+    const text = args.join(' ').trim() || `codex-mcp-test-${Date.now()}`;
+    const result = await send('tools/call', {
+      name: 'nado_save_flashcard',
+      arguments: {
+        original: text,
+        type: text.split(/\s+/).length > 1 ? 'phrase' : 'word',
+        definition: `Probe definition for ${text}`,
+        inlineDefinition: `Probe: ${text}`,
+        explanation: 'Saved from the local MCP probe without Nado AI.',
+        exampleSentences: [`Codex saved "${text}" through the Nado MCP server.`],
+        variants: [],
+        contextSentence: `Codex saved "${text}" through the Nado MCP server.`,
+        articleTitle: 'Codex MCP Probe',
+        articleId: 'codex-mcp-probe',
+        sourceHighlightId: `codex-mcp-probe-${Date.now()}`,
+      },
+    });
+    console.log(result.content?.[0]?.text || JSON.stringify(result, null, 2));
+  } else if (mode === 'save-nado-ai') {
+    const text = args.join(' ').trim() || `codex-mcp-pro-${Date.now()}`;
+    const result = await send('tools/call', {
+      name: 'nado_analyze_and_save_flashcard',
+      arguments: {
+        original: text,
+        contextSentence: `Codex asked Nado AI to analyze "${text}" through the MCP server.`,
+        articleTitle: 'Codex MCP Pro Probe',
+        articleId: 'codex-mcp-pro-probe',
+        sourceHighlightId: `codex-mcp-pro-${Date.now()}`,
+      },
+    });
+    console.log(result.content?.[0]?.text || JSON.stringify(result, null, 2));
+  } else if (mode === 'list-items') {
+    const query = args.join(' ').trim();
+    const result = await send('tools/call', {
+      name: 'nado_list_study_items',
+      arguments: { query, limit: 10 },
+    });
+    console.log(result.content?.[0]?.text || JSON.stringify(result, null, 2));
+  } else if (mode === 'practice') {
+    const practiceMode = args[0] || 'sentence_completion';
+    const query = args.slice(1).join(' ').trim();
+    const result = await send('tools/call', {
+      name: 'nado_generate_practice',
+      arguments: { mode: practiceMode, query, limit: 3 },
+    });
+    console.log(result.content?.[0]?.text || JSON.stringify(result, null, 2));
+  } else if (mode === 'verify-admin') {
+    const text = args.join(' ').trim() || `codex-mcp-admin-${Date.now()}`;
+    const verification = await verifyAdminFlow(text);
+    console.log(JSON.stringify(verification, null, 2));
+  } else {
+    throw new Error(`Unknown probe mode: ${mode}`);
+  }
+} catch (error) {
+  console.error(`Nado MCP probe failed: ${error instanceof Error ? error.message : String(error)}`);
+  process.exitCode = 1;
+} finally {
+  child.stdin.end();
+}
+
+async function callTool(name, toolArgs = {}) {
+  const result = await send('tools/call', { name, arguments: toolArgs });
+  const text = result.content?.[0]?.text;
+  const parsed = text ? JSON.parse(text) : result.structuredContent;
+  if (result.isError || parsed?.error) {
+    throw new Error(parsed?.error || `Tool failed: ${name}`);
+  }
+  return parsed;
+}
+
+async function verifyAdminFlow(text) {
+  const whoami = await callTool('nado_whoami');
+  const identity = [
+    whoami.user?.email,
+    whoami.profile?.display_name,
+    whoami.profile?.provider,
+    whoami.profile?.id,
+  ].filter(Boolean).join(' ').toLowerCase();
+
+  if (!identity.includes('jintonyc')) {
+    throw new Error(`EXPECTED_ADMIN_JINTONYC: authenticated account did not look like jintonyc (${identity || 'empty identity'})`);
+  }
+
+  const saved = await callTool('nado_save_flashcard', {
+    original: text,
+    type: text.split(/\s+/).length > 1 ? 'phrase' : 'word',
+    definition: `Admin verification definition for ${text}`,
+    inlineDefinition: `Admin verification: ${text}`,
+    explanation: 'Saved from the MCP admin verification without Nado AI cost.',
+    exampleSentences: [`Codex verification saved "${text}" through the Nado MCP server.`],
+    variants: [],
+    contextSentence: `Codex verification saved "${text}" through the Nado MCP server.`,
+    articleTitle: 'Codex MCP Admin Verification',
+    articleId: 'codex-mcp-admin-verification',
+    sourceHighlightId: `codex-mcp-admin-${Date.now()}`,
+  });
+
+  const listed = await callTool('nado_list_study_items', { query: text, limit: 10 });
+  const savedCard = listed.items?.find((item) => item.id === saved.flashcard?.id || item.original === text);
+  if (!savedCard) {
+    throw new Error(`SAVED_CARD_NOT_FOUND: ${text}`);
+  }
+
+  const practice = await callTool('nado_generate_practice', {
+    mode: 'sentence_completion',
+    query: text,
+    limit: 3,
+  });
+
+  const materialIds = new Set((practice.materials || []).map((item) => item.id));
+  const exerciseIds = new Set((practice.exercises || []).flatMap((exercise) => exercise.sourceCardIds || []));
+  const citesOnlySavedMaterials = [...exerciseIds].every((id) => materialIds.has(id));
+
+  if (practice.onlySavedMaterials !== true || !citesOnlySavedMaterials || practice.exercises?.length < 1) {
+    throw new Error('PRACTICE_POLICY_FAILED: generated practice did not prove saved-material-only usage.');
+  }
+
+  return {
+    ok: true,
+    user: whoami.user,
+    profile: whoami.profile,
+    savedFlashcardId: saved.flashcard.id,
+    savedOriginal: saved.flashcard.original,
+    listedCount: listed.count,
+    practiceMode: practice.mode,
+    practiceMaterialCount: practice.materialCount,
+    practiceExerciseCount: practice.exercises.length,
+    onlySavedMaterials: practice.onlySavedMaterials,
+    citedSourceCardIds: [...exerciseIds],
+  };
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@nado-language/mcp",
+  "version": "0.1.0",
+  "description": "Nado Language MCP server for saving AI-generated English flashcards and practicing saved materials.",
+  "type": "module",
+  "private": false,
+  "license": "UNLICENSED",
+  "bin": {
+    "nado-mcp": "dist/nado-mcp-cli.mjs",
+    "nado-mcp-server": "dist/nado-language-server.mjs",
+    "nado-mcp-auth": "dist/nado-mcp-auth.mjs"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "prepack": "node ../../scripts/build-nado-mcp-package.mjs",
+    "test": "node dist/nado-mcp-cli.mjs doctor"
+  },
+  "keywords": [
+    "mcp",
+    "nado",
+    "language-learning",
+    "flashcards"
+  ]
+}