sysmledgraph 0.7.0

package/scripts/debug-lsp-symbols.mjs

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+/**
+ * Debug: what does the LSP return for documentSymbol, and what do we normalize?
+ * Run from repo root after build: node scripts/debug-lsp-symbols.mjs [file]
+ * Uses SYSMLLSP_SERVER_PATH or default node_modules path.
+ */
+import { readFile } from 'fs/promises';
+import { resolve } from 'path';
+import { existsSync } from 'fs';
+
+const pathArg = process.argv[2] || 'test/fixtures/sysml/sample.sysml';
+const absPath = resolve(process.cwd(), pathArg);
+if (!existsSync(absPath)) {
+  console.error('File not found:', absPath);
+  process.exit(1);
+}
+
+if (!process.env.SYSMLLSP_SERVER_PATH) {
+  const lspPath = resolve(process.cwd(), 'lsp/node_modules/sysml-v2-lsp/dist/server/server.js');
+  const rootPath = resolve(process.cwd(), 'node_modules/sysml-v2-lsp/dist/server/server.js');
+  if (existsSync(lspPath)) process.env.SYSMLLSP_SERVER_PATH = lspPath;
+  else if (existsSync(rootPath)) process.env.SYSMLLSP_SERVER_PATH = rootPath;
+}
+
+async function main() {
+  const content = await readFile(absPath, 'utf-8');
+  console.log('File:', absPath);
+  console.log('Content length:', content.length, 'bytes\n');
+
+  const { getDocumentSymbolsFromLsp, closeLspClient } = await import('../dist/src/parser/lsp-client.js');
+  const { getSymbolsForFile } = await import('../dist/src/parser/symbols.js');
+
+  try {
+    console.log('Calling LSP getDocumentSymbols...');
+    const raw = await getDocumentSymbolsFromLsp(absPath, content);
+    console.log('--- Raw LSP documentSymbol result ---');
+    const rawArr = Array.isArray(raw) ? raw : (raw != null && typeof raw === 'object' ? [raw] : []);
+    try {
+      console.log(JSON.stringify(rawArr, null, 2));
+    } catch (e) {
+      console.log('(stringify failed)', String(e));
+    }
+    console.log('Count:', rawArr.length);
+    if (rawArr.length > 0 && rawArr[0]) {
+      const first = rawArr[0];
+      console.log('First symbol keys:', Object.keys(first));
+      console.log('First symbol detail:', first.detail, 'name:', first.name);
+    }
+
+    console.log('Calling getSymbolsForFile...');
+    const normalized = await getSymbolsForFile(absPath, content);
+    console.log('\n--- Normalized symbols (fed to graph) ---');
+    console.log(JSON.stringify(normalized, null, 2));
+    console.log('Count:', normalized?.length ?? 0);
+  } catch (err) {
+    console.error('Error:', err);
+    throw err;
+  } finally {
+    closeLspClient();
+  }
+}
+main().catch((e) => { console.error(e); process.exit(1); });

package/scripts/deploy-skills.mjs

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+/**
+ * Deploy Agent Skills for Cursor.
+ *
+ * Default: sync GitNexus skills from .claude/skills/gitnexus/ → .cursor/skills/
+ *   (source of truth for those skills lives under .claude for Claude Code parity)
+ *
+ * --user: copy the same GitNexus skills to ~/.cursor/skills/ (all projects)
+ */
+
+import { cpSync, readdirSync, statSync, mkdirSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import os from 'os';
+
+const root = join(dirname(fileURLToPath(import.meta.url)), '..');
+const srcDir = join(root, '.claude', 'skills', 'gitnexus');
+const userMode = process.argv.includes('--user');
+const dstRoot = userMode ? join(os.homedir(), '.cursor', 'skills') : join(root, '.cursor', 'skills');
+
+if (!existsSync(srcDir)) {
+  console.error('Missing source:', srcDir);
+  process.exit(1);
+}
+
+mkdirSync(dstRoot, { recursive: true });
+
+let count = 0;
+for (const name of readdirSync(srcDir)) {
+  const p = join(srcDir, name);
+  if (!statSync(p).isDirectory()) continue;
+  const dest = join(dstRoot, name);
+  cpSync(p, dest, { recursive: true });
+  console.log(dest);
+  count++;
+}
+
+console.log(
+  `\nDeployed ${count} GitNexus skill(s) to ${userMode ? join(os.homedir(), '.cursor', 'skills') : '.cursor/skills/'}`
+);
+if (!userMode) {
+  console.log('Tip: npm run deploy-skills -- --user  → copy to personal ~/.cursor/skills/');
+}

package/scripts/example-sysml-mcp.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+/**
+ * Example: use SysML MCP as a lib from code.
+ * Build first: npm run build
+ * Run: node scripts/example-sysml-mcp.mjs
+ */
+import { createSysmlMcpClient } from '../dist/src/parser/sysml-mcp-client.js';
+
+const code = `package Example {
+  requirement ReqOne {
+    doc /* requirement one */ "Req one.";
+  }
+}`;
+
+const client = await createSysmlMcpClient();
+try {
+  const parseResult = await client.parse(code, 'file:///example.sysml');
+  console.log('parse:', JSON.stringify(parseResult, null, 2));
+
+  const validateResult = await client.validate(code, 'file:///example.sysml');
+  console.log('validate:', JSON.stringify(validateResult, null, 2));
+
+  const symbolsResult = await client.getSymbols(code, 'file:///example.sysml');
+  console.log('getSymbols count:', symbolsResult.count);
+} finally {
+  client.close();
+}

package/scripts/export-graph.mjs

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+/**
+ * Export the first indexed graph to JSON (nodes + edges) for viewing.
+ * Usage: node scripts/export-graph.mjs [output.json]
+ * Default output: graph-export.json in current directory.
+ * If the registry is empty, uses the first .kuzu file in storage db/ (e.g. after clean or CLI-only use).
+ */
+import { readFile, writeFile, readdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const kuzu = require('kuzu');
+const { EDGE_TYPES, NODE_TABLE } = await import('../dist/src/graph/schema.js');
+
+const NODE_LIMIT = 1000;
+const EDGE_LIMIT_PER_TYPE = 500;
+
+const storageRoot = process.env.SYSMEDGRAPH_STORAGE_ROOT || join(homedir(), '.sysmledgraph');
+const dbDir = join(storageRoot, 'db');
+const registryPath = join(storageRoot, 'registry.json');
+const outPath = process.argv[2] || 'graph-export.json';
+
+// One merged graph DB (plan step 8)
+const MERGED_DB_FILENAME = 'graph.kuzu';
+let dbPath = join(dbDir, MERGED_DB_FILENAME);
+if (!existsSync(dbPath)) {
+  try {
+    const files = await readdir(dbDir);
+    const kuzuFile = files.find((f) => f.endsWith('.kuzu') && !f.endsWith('.kuzu.wal'));
+    if (kuzuFile) dbPath = join(dbDir, kuzuFile);
+    else dbPath = null;
+  } catch {
+    dbPath = null;
+  }
+}
+if (!dbPath) {
+  console.error('No indexed paths and no DB in storage. Run: npx sysmledgraph analyze <path>');
+  process.exit(1);
+}
+
+const db = new kuzu.Database(dbPath);
+const conn = new kuzu.Connection(db);
+
+const nodeResult = await conn.query(
+  `MATCH (n:${NODE_TABLE}) RETURN n.id, n.name, n.path, n.label LIMIT ${NODE_LIMIT}`
+);
+const nodeRows = await nodeResult.getAll();
+const nodes = nodeRows.map((r) => {
+  const v = Array.isArray(r) ? r : Object.values(r);
+  return { id: String(v[0]), name: String(v[1] ?? ''), path: String(v[2] ?? ''), label: String(v[3] ?? '') };
+});
+
+const nodeIds = new Set(nodes.map((n) => n.id));
+const edges = [];
+for (const relType of EDGE_TYPES) {
+  try {
+    const relResult = await conn.query(
+      `MATCH (a:${NODE_TABLE})-[:${relType}]->(b:${NODE_TABLE}) RETURN a.id, b.id LIMIT ${EDGE_LIMIT_PER_TYPE}`
+    );
+    const relRows = await relResult.getAll();
+    for (const row of relRows) {
+      const v = Array.isArray(row) ? row : Object.values(row);
+      const from = String(v[0]);
+      const to = String(v[1]);
+      if (nodeIds.has(from) && nodeIds.has(to)) edges.push({ from, to, type: relType });
+    }
+  } catch {
+    // rel table may not exist
+  }
+}
+
+conn.close();
+db.close();
+
+const payload = { nodes, edges, meta: { nodeLimit: NODE_LIMIT, edgeCount: edges.length } };
+await writeFile(outPath, JSON.stringify(payload, null, 0), 'utf-8');
+console.log(`Wrote ${nodes.length} nodes, ${edges.length} edges to ${outPath}`);
+console.log('Open viewer/view.html in a browser and load this file to view the graph.');

package/scripts/generate-map.mjs

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+/**
+ * Generate a markdown map from the graph (interconnection view, packages, documents).
+ * Plan After v1 / Gap #6. Usage: node scripts/generate-map.mjs [output.md]
+ * Default output: graph-map.md in current directory.
+ * Uses the same merged DB as export-graph (storage db/graph.kuzu).
+ */
+import { writeFile, readdir } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
+import { existsSync } from 'fs';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const kuzu = require('kuzu');
+const { NODE_TABLE, EDGE_TYPES } = await import('../dist/src/graph/schema.js');
+
+const storageRoot = process.env.SYSMEDGRAPH_STORAGE_ROOT || join(homedir(), '.sysmledgraph');
+const dbDir = join(storageRoot, 'db');
+const MERGED_DB_FILENAME = 'graph.kuzu';
+let dbPath = join(dbDir, MERGED_DB_FILENAME);
+if (!existsSync(dbPath)) {
+  try {
+    const files = await readdir(dbDir);
+    const kuzuFile = files.find((f) => f.endsWith('.kuzu') && !f.endsWith('.kuzu.wal'));
+    if (kuzuFile) dbPath = join(dbDir, kuzuFile);
+    else dbPath = null;
+  } catch {
+    dbPath = null;
+  }
+}
+if (!dbPath) {
+  console.error('No graph DB found. Run: npx sysmledgraph analyze <path>');
+  process.exit(1);
+}
+
+const outPath = process.argv[2] || 'graph-map.md';
+const db = new kuzu.Database(dbPath);
+const conn = new kuzu.Connection(db);
+
+const lines = ['# Graph map (interconnection view)', ''];
+
+// Documents
+const docResult = await conn.query(
+  `MATCH (n:${NODE_TABLE}) WHERE n.label = 'Document' RETURN n.id, n.path ORDER BY n.path LIMIT 500`
+);
+const docRows = await docResult.getAll();
+lines.push('## Documents');
+if (docRows.length === 0) lines.push('(none)');
+else docRows.forEach((r) => { const v = Array.isArray(r) ? r : Object.values(r); lines.push(`- ${String(v[1] ?? v[0])}`); });
+lines.push('');
+
+// Nodes by label (Package, PartDef, RequirementDef, etc.)
+const nodeResult = await conn.query(
+  `MATCH (n:${NODE_TABLE}) RETURN n.label, n.id, n.name, n.path ORDER BY n.label, n.name LIMIT 10000`
+);
+const nodeRows = await nodeResult.getAll();
+const byLabel = new Map();
+for (const r of nodeRows) {
+  const v = Array.isArray(r) ? r : Object.values(r);
+  const label = String(v[0] ?? '');
+  const id = String(v[1] ?? '');
+  const name = String(v[2] ?? '');
+  const path = String(v[3] ?? '');
+  if (!byLabel.has(label)) byLabel.set(label, []);
+  byLabel.get(label).push({ id, name, path });
+}
+lines.push('## Nodes by label');
+for (const [label, nodes] of [...byLabel.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+  lines.push(`### ${label}`);
+  lines.push('| name | path | id |');
+  lines.push('|------|------|-----|');
+  for (const n of nodes) {
+    lines.push(`| ${n.name} | ${n.path} | ${n.id} |`);
+  }
+  lines.push('');
+}
+
+// Edges (Interconnection)
+lines.push('## Interconnection (edges)');
+lines.push('| from | type | to |');
+lines.push('|------|------|-----|');
+let edgeCount = 0;
+const edgeLimit = 500;
+for (const relType of EDGE_TYPES) {
+  try {
+    const relResult = await conn.query(
+      `MATCH (a:${NODE_TABLE})-[:${relType}]->(b:${NODE_TABLE}) RETURN a.id, b.id LIMIT ${Math.ceil(edgeLimit / EDGE_TYPES.length)}`
+    );
+    const relRows = await relResult.getAll();
+    for (const row of relRows) {
+      const v = Array.isArray(row) ? row : Object.values(row);
+      lines.push(`| ${String(v[0])} | ${relType} | ${String(v[1])} |`);
+      edgeCount++;
+    }
+  } catch {
+    // rel table may not exist
+  }
+}
+if (edgeCount === 0) {
+  lines.push('| (none) | | |');
+  lines.push('');
+  lines.push('_No edges: graph has only Document nodes. Edges appear when the indexer gets LSP symbols (e.g. Package, PartDef) and writes IN_DOCUMENT / IN_PACKAGE relations._');
+  lines.push('');
+}
+
+conn.close();
+db.close();
+
+await writeFile(outPath, lines.join('\n'), 'utf-8');
+console.log(`Wrote ${outPath}`);

package/scripts/index-and-map.mjs

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+/**
+ * Index a path with SysML files, then generate the graph map.
+ * Usage: node scripts/index-and-map.mjs [path]
+ * Default path: test/fixtures/sysml
+ * Output: graph-map.md in project root (or run npm run generate-map for custom path).
+ */
+import { spawn } from 'child_process';
+import { resolve } from 'path';
+import { existsSync } from 'fs';
+
+const pathArg = process.argv[2] || 'test/fixtures/sysml';
+const absPath = resolve(process.cwd(), pathArg);
+
+// Default LSP server: prefer lsp/node_modules (dedicated init) then repo node_modules
+if (!process.env.SYSMLLSP_SERVER_PATH) {
+  const lspServer = resolve(process.cwd(), 'lsp/node_modules/sysml-v2-lsp/dist/server/server.js');
+  const rootServer = resolve(process.cwd(), 'node_modules/sysml-v2-lsp/dist/server/server.js');
+  if (existsSync(lspServer)) process.env.SYSMLLSP_SERVER_PATH = lspServer;
+  else if (existsSync(rootServer)) process.env.SYSMLLSP_SERVER_PATH = rootServer;
+}
+
+console.log('Indexing:', absPath);
+const analyze = spawn('node', ['dist/bin/cli.js', 'analyze', absPath], {
+  cwd: process.cwd(),
+  stdio: 'inherit',
+  env: { ...process.env },
+});
+const code = await new Promise((res) => analyze.on('close', res));
+if (code !== 0) {
+  console.error('Analyze failed. Ensure kuzu is built (npm install, no --ignore-scripts).');
+  process.exit(code);
+}
+
+console.log('\nGenerating map...');
+const map = spawn('node', ['scripts/generate-map.mjs', 'graph-map.md'], {
+  cwd: process.cwd(),
+  stdio: 'inherit',
+});
+const mapCode = await new Promise((res) => map.on('close', res));
+if (mapCode !== 0) process.exit(mapCode);
+
+console.log('\nMap written to graph-map.md');

package/scripts/index-and-query.mjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+/**
+ * Index one path then run a count query in the same process (same DB).
+ * Usage: set SYSMLLSP_SERVER_PATH then run:
+ *   node scripts/index-and-query.mjs "c:\Projects\SystemDesign\sysml-v2-models\projects\sysmledgraph"
+ */
+import { homedir } from 'os';
+import { join } from 'path';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+const pathToIndex = process.argv[2];
+if (!pathToIndex) {
+  console.error('Usage: node scripts/index-and-query.mjs <path>');
+  process.exit(1);
+}
+
+const storageRoot = join(homedir(), '.sysmledgraph');
+const sanitized = pathToIndex.replace(/[:\\/]/g, '_').replace(/_+/g, '_') || 'root';
+const dbPath = join(storageRoot, 'db', sanitized + '.kuzu');
+
+// Use compiled indexer and graph
+const { openGraphStore } = await import('../dist/src/graph/graph-store.js');
+const { runIndexer } = await import('../dist/src/indexer/indexer.js');
+
+try {
+  const store = await openGraphStore(dbPath);
+  const result = await runIndexer(store, { roots: [pathToIndex] });
+  console.log('Index result:', result);
+
+  const conn = store.getConnection();
+  const q = await conn.query('MATCH (n) RETURN count(n) AS count');
+  const rows = await q.getAll();
+  console.log('Count:', rows);
+  process.exit(result.ok ? 0 : 1);
+} catch (err) {
+  console.error('Error:', err);
+  process.exit(1);
+}

package/scripts/query-one.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+/**
+ * Run one Cypher query against the first indexed DB (for manual testing).
+ * Use label Node for our schema, e.g. MATCH (n:Node) RETURN count(n) AS count
+ * Usage: node scripts/query-one.mjs "MATCH (n:Node) RETURN count(n) AS count"
+ */
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const kuzu = require('kuzu');
+
+const storageRoot = join(homedir(), '.sysmledgraph');
+const registryPath = join(storageRoot, 'registry.json');
+const query = process.argv[2] || 'MATCH (n:Node) RETURN count(n) AS count';
+
+const raw = await readFile(registryPath, 'utf-8');
+const { paths } = JSON.parse(raw);
+if (!paths?.length) {
+  console.error('No indexed paths in registry');
+  process.exit(1);
+}
+const indexedPath = paths[0];
+const sanitized = indexedPath.replace(/[:\\/]/g, '_').replace(/_+/g, '_') || 'root';
+const dbPath = join(storageRoot, 'db', sanitized + '.kuzu');
+
+const db = new kuzu.Database(dbPath);
+const conn = new kuzu.Connection(db);
+const result = await conn.query(query);
+const rows = await result.getAll();
+console.log(JSON.stringify(rows, null, 2));
+conn.close();
+db.close();

package/scripts/setup-lsp.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+/**
+ * Install the LSP server in lsp/ (sysml-v2-lsp). Used by sysmledgraph for indexing.
+ * Run: npm run setup-lsp  or  node scripts/setup-lsp.mjs
+ * Exit 0 if lsp/node_modules/sysml-v2-lsp/dist/server/server.js already exists or install succeeds.
+ */
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { spawn } from 'child_process';
+
+const cwd = resolve(process.cwd(), 'lsp');
+const serverPath = resolve(cwd, 'node_modules/sysml-v2-lsp/dist/server/server.js');
+
+if (existsSync(serverPath)) {
+  console.log('LSP already installed at', serverPath);
+  process.exit(0);
+}
+
+console.log('Installing LSP in lsp/...');
+const proc = spawn('npm', ['install', '--ignore-scripts'], { cwd, stdio: 'inherit' });
+proc.on('close', (code) => {
+  if (code !== 0) {
+    console.error('npm install in lsp/ failed with code', code);
+    process.exit(code ?? 1);
+  }
+  if (!existsSync(serverPath)) {
+    console.error('LSP server not found at', serverPath, '- install may be incomplete.');
+    process.exit(1);
+  }
+  console.log('LSP installed. Run index-and-map or analyze without SYSMLLSP_SERVER_PATH.');
+  process.exit(0);
+});
+proc.on('error', (err) => {
+  console.error('Failed to run npm:', err.message);
+  process.exit(1);
+});

package/scripts/test-lsp.mjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+/**
+ * Test LSP: get document symbols for each modelbase-development .sysml file.
+ * Run from repo root: node scripts/test-lsp.mjs
+ * Requires SYSMLLSP_SERVER_PATH → path to sysml-v2-lsp dist/server/server.js.
+ */
+import { readFile } from 'fs/promises';
+import { resolve } from 'path';
+
+const root = resolve(process.cwd(), 'modelbase-development', 'models');
+const allFiles = [
+  'requirements-modelbase-development.sysml',
+  'deploy-modelbase-development.sysml',
+  'behaviour-modelbase-development.sysml',
+  'project-modelbase-development.sysml',
+];
+// Run only first N files when SYSMLEDGRAPH_LSP_FILES=N
+const fileLimit = Number(process.env.SYSMLEDGRAPH_LSP_FILES) || allFiles.length;
+const files = allFiles.slice(0, fileLimit);
+
+async function main() {
+  const { closeLspClient } = await import('../dist/src/parser/lsp-client.js');
+  const { getSymbolsForFile } = await import('../dist/src/parser/symbols.js');
+
+  console.log('Testing LSP (client created on first getSymbolsForFile)...\n');
+
+  const timeoutMs = Math.min(10000, Math.max(1000, Number(process.env.SYSMLEDGRAPH_LSP_TIMEOUT_MS) || 10000));
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    const filePath = resolve(root, file);
+    console.log(`[${i + 1}/${files.length}] ${file}`);
+    const t0 = Date.now();
+    try {
+      const content = await readFile(filePath, 'utf-8');
+      const symbols = await Promise.race([
+        getSymbolsForFile(filePath, content),
+        new Promise((_, rej) => setTimeout(() => rej(new Error(`getSymbolsForFile timeout ${timeoutMs}ms`)), timeoutMs)),
+      ]);
+      const elapsed = Date.now() - t0;
+      console.log(`  -> ${symbols.length} symbols in ${elapsed}ms`);
+      const labels = [...new Set(symbols.map((s) => s.label))];
+      if (labels.length) console.log(`  -> labels: ${labels.join(', ')}`);
+    } catch (err) {
+      console.error(`  -> ERROR (${Date.now() - t0}ms):`, err instanceof Error ? err.message : err);
+    }
+  }
+
+  closeLspClient();
+  console.log('\nDone.');
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});

package/scripts/test-mcp-debug.mjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+/** Quick debug: spawn MCP server, send initialize, log all stdout/stderr. */
+import { spawn } from 'child_process';
+import { resolve } from 'path';
+
+const PROJECT_ROOT = resolve(process.cwd());
+const MCP_PATH = resolve(PROJECT_ROOT, 'node_modules/sysml-v2-lsp/dist/server/mcpServer.js');
+
+const child = spawn('node', [MCP_PATH], { cwd: PROJECT_ROOT, stdio: ['pipe', 'pipe', 'pipe'] });
+
+child.stdout.on('data', (chunk) => {
+  console.log('[stdout]', chunk.length, 'bytes:', chunk.toString('utf-8').slice(0, 200));
+});
+child.stderr.on('data', (chunk) => {
+  process.stderr.write('[stderr] ' + chunk.toString('utf-8'));
+});
+
+// Send initialize with Content-Length framing
+const body = JSON.stringify({
+  jsonrpc: '2.0',
+  id: 1,
+  method: 'initialize',
+  params: { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'debug', version: '0.1.0' } },
+});
+const bytes = Buffer.from(body, 'utf-8');
+child.stdin.write(`Content-Length: ${bytes.length}\r\n\r\n` + body);
+
+setTimeout(() => {
+  console.log('\n[timeout - killing]');
+  child.kill();
+  process.exit(0);
+}, 25000);

package/scripts/test-mcp-sysml.mjs

@@ -0,0 +1,75 @@
+/**
+ * Test sysml-v2-lsp MCP: spawn server, send initialize + tools/list, print result.
+ */
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import path from 'path';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(__dirname, '..');
+const mcpPath = path.join(projectRoot, 'sysml-v2-lsp', 'dist', 'server', 'mcpServer.js');
+
+const child = spawn('node', [mcpPath], {
+  cwd: projectRoot,
+  stdio: ['pipe', 'pipe', 'pipe'],
+});
+
+let buffer = '';
+let gotInit = false;
+let gotTools = false;
+
+function send(obj) {
+  child.stdin.write(JSON.stringify(obj) + '\n');
+}
+
+child.stdout.setEncoding('utf8');
+child.stdout.on('data', (chunk) => {
+  buffer += chunk;
+  const lines = buffer.split('\n').filter(Boolean);
+  buffer = lines.pop() ?? '';
+  for (const line of lines) {
+    try {
+      const res = JSON.parse(line);
+      if (res.result?.capabilities != null) {
+        gotInit = true;
+        console.log('✅ initialize OK — server:', res.result.serverInfo?.name ?? 'sysml-v2');
+      }
+      if (res.result?.tools != null) {
+        gotTools = true;
+        const tools = res.result.tools;
+        console.log('✅ tools/list OK —', tools.length, 'tools');
+        console.log('   Sample:', tools.slice(0, 6).map((t) => t.name).join(', '));
+        child.kill();
+        process.exit(0);
+      }
+    } catch (_) {}
+  }
+});
+
+child.stderr.on('data', (d) => process.stderr.write(d));
+child.on('error', (err) => {
+  console.error('❌ spawn error:', err.message);
+  process.exit(1);
+});
+
+send({
+  jsonrpc: '2.0',
+  id: 1,
+  method: 'initialize',
+  params: {
+    protocolVersion: '2024-11-05',
+    capabilities: {},
+    clientInfo: { name: 'test-mcp', version: '0.1.0' },
+  },
+});
+// After initialize, client sends initialized notification, then other requests
+send({ jsonrpc: '2.0', method: 'notifications/initialized' });
+send({ jsonrpc: '2.0', id: 2, method: 'tools/list' });
+
+setTimeout(() => {
+  if (!gotTools) {
+    console.error('❌ timeout (no tools/list response)');
+    child.kill();
+  }
+  process.exit(gotTools ? 0 : 1);
+}, 8000);