@papyruslabsai/seshat-mcp 0.3.3 → 0.4.0

package/dist/bootstrap.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Auto-Bootstrap — extract a .seshat/ bundle on first run.
+ *
+ * When the MCP server starts and finds no .seshat/_bundle.json, this module
+ * spawns `npx @papyruslabsai/seshat-extract` to generate one on the fly.
+ *
+ * CI continues to regenerate the bundle on every merge to main, overwriting
+ * the bootstrap result. The bootstrap only runs when .seshat/ doesn't exist.
+ *
+ * Env vars:
+ *   SESHAT_BOOTSTRAP_TIMEOUT — spawn timeout in ms (default: 120000)
+ */
+export interface BootstrapResult {
+    success: boolean;
+    entityCount: number;
+    languages: string[];
+    durationMs: number;
+    error?: string;
+}
+/**
+ * Auto-bootstrap: extract a .seshat/ bundle for the given project directory.
+ *
+ * Spawns `npx @papyruslabsai/seshat-extract <dir> <dir>/.seshat <name>`
+ * and waits for it to complete.
+ *
+ * @param projectDir - Absolute path to the project root
+ * @returns Bootstrap result with entity count, languages, duration, and any error
+ */
+export declare function bootstrap(projectDir: string): Promise<BootstrapResult>;

package/dist/bootstrap.js

@@ -0,0 +1,187 @@
+/**
+ * Auto-Bootstrap — extract a .seshat/ bundle on first run.
+ *
+ * When the MCP server starts and finds no .seshat/_bundle.json, this module
+ * spawns `npx @papyruslabsai/seshat-extract` to generate one on the fly.
+ *
+ * CI continues to regenerate the bundle on every merge to main, overwriting
+ * the bootstrap result. The bootstrap only runs when .seshat/ doesn't exist.
+ *
+ * Env vars:
+ *   SESHAT_BOOTSTRAP_TIMEOUT — spawn timeout in ms (default: 120000)
+ */
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+// Project marker files — presence of any means "this is a code project"
+const PROJECT_MARKERS = [
+    '.git',
+    'package.json',
+    'go.mod',
+    'Cargo.toml',
+    'pyproject.toml',
+    'pom.xml',
+    'build.gradle',
+    'Makefile',
+    'CMakeLists.txt',
+];
+/**
+ * Check if a directory looks like a code project.
+ */
+function isCodeProject(dir) {
+    for (const marker of PROJECT_MARKERS) {
+        const markerPath = path.join(dir, marker);
+        if (fs.existsSync(markerPath))
+            return true;
+    }
+    // Also check for *.sln files (C# solutions)
+    try {
+        const entries = fs.readdirSync(dir);
+        if (entries.some(e => e.endsWith('.sln')))
+            return true;
+    }
+    catch { }
+    return false;
+}
+/**
+ * Infer a project name from the directory.
+ * Priority: package.json name → git remote → directory basename
+ */
+function inferProjectName(dir) {
+    // 1. Try package.json
+    try {
+        const pkgPath = path.join(dir, 'package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        if (pkg.name) {
+            return pkg.name.replace(/^@[^/]+\//, '');
+        }
+    }
+    catch { }
+    // 2. Try git remote
+    try {
+        const remote = execSync('git remote get-url origin', {
+            cwd: dir, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe']
+        }).trim();
+        const match = remote.match(/\/([^/]+?)(?:\.git)?$/);
+        if (match)
+            return match[1];
+    }
+    catch { }
+    // 3. Fallback: directory basename
+    return path.basename(dir);
+}
+/**
+ * Auto-bootstrap: extract a .seshat/ bundle for the given project directory.
+ *
+ * Spawns `npx @papyruslabsai/seshat-extract <dir> <dir>/.seshat <name>`
+ * and waits for it to complete.
+ *
+ * @param projectDir - Absolute path to the project root
+ * @returns Bootstrap result with entity count, languages, duration, and any error
+ */
+export async function bootstrap(projectDir) {
+    const startTime = Date.now();
+    const timeoutMs = parseInt(process.env.SESHAT_BOOTSTRAP_TIMEOUT || '120000', 10);
+    // Sanity checks
+    if (!isCodeProject(projectDir)) {
+        return {
+            success: false,
+            entityCount: 0,
+            languages: [],
+            durationMs: Date.now() - startTime,
+            error: `${projectDir} does not appear to be a code project (no package.json, .git, go.mod, etc.)`,
+        };
+    }
+    const seshatDir = path.join(projectDir, '.seshat');
+    const projectName = inferProjectName(projectDir);
+    process.stderr.write(`[seshat-mcp] Auto-bootstrap: extracting ${projectName} from ${projectDir}\n`);
+    return new Promise((resolve) => {
+        // On Windows, npx is npx.cmd
+        const isWindows = process.platform === 'win32';
+        const npxCmd = isWindows ? 'npx.cmd' : 'npx';
+        const child = spawn(npxCmd, ['-y', '@papyruslabsai/seshat-extract', projectDir, seshatDir, projectName], {
+            cwd: projectDir,
+            shell: isWindows, // Windows needs shell: true for .cmd files
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: timeoutMs,
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        child.stderr?.on('data', (data) => {
+            const text = data.toString();
+            stderr += text;
+            // Forward progress to parent stderr
+            process.stderr.write(`[seshat-extract] ${text}`);
+        });
+        child.on('error', (err) => {
+            resolve({
+                success: false,
+                entityCount: 0,
+                languages: [],
+                durationMs: Date.now() - startTime,
+                error: `Failed to spawn seshat-extract: ${err.message}`,
+            });
+        });
+        child.on('close', (code) => {
+            const durationMs = Date.now() - startTime;
+            if (code !== 0) {
+                resolve({
+                    success: false,
+                    entityCount: 0,
+                    languages: [],
+                    durationMs,
+                    error: `seshat-extract exited with code ${code}. stderr: ${stderr.slice(-500)}`,
+                });
+                return;
+            }
+            // Parse the JSON result from stdout
+            try {
+                const result = JSON.parse(stdout.trim());
+                if (result.ok) {
+                    process.stderr.write(`[seshat-mcp] Bootstrap complete: ${result.entities} entities, ${result.languages?.join(', ')} in ${(durationMs / 1000).toFixed(1)}s\n`);
+                    resolve({
+                        success: true,
+                        entityCount: result.entities || 0,
+                        languages: result.languages || [],
+                        durationMs,
+                    });
+                }
+                else {
+                    resolve({
+                        success: false,
+                        entityCount: 0,
+                        languages: [],
+                        durationMs,
+                        error: result.error || 'Unknown extraction error',
+                    });
+                }
+            }
+            catch {
+                // JSON parse failed — check if bundle was written anyway
+                const bundlePath = path.join(seshatDir, '_bundle.json');
+                if (fs.existsSync(bundlePath)) {
+                    process.stderr.write(`[seshat-mcp] Bootstrap produced bundle but JSON result was malformed. Proceeding.\n`);
+                    resolve({
+                        success: true,
+                        entityCount: 0,
+                        languages: [],
+                        durationMs,
+                    });
+                }
+                else {
+                    resolve({
+                        success: false,
+                        entityCount: 0,
+                        languages: [],
+                        durationMs,
+                        error: `seshat-extract succeeded but produced no parseable result. stdout: ${stdout.slice(-200)}`,
+                    });
+                }
+            }
+        });
+    });
+}

package/dist/index.js

@@ -44,6 +44,7 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { MultiLoader } from './loader.js';
+import { bootstrap } from './bootstrap.js';
 import { initTools, queryEntities, getEntity, getDependencies, getDataFlow, findByConstraint, getBlastRadius, listModules, getTopology, } from './tools/index.js';
 import { findDeadCode, findLayerViolations, getCouplingMetrics, getAuthMatrix, findErrorGaps, getTestCoverage, getOptimalContext, estimateTaskCost, reportActualBurn, } from './tools/functors.js';
 // ─── Project Discovery ───────────────────────────────────────────
@@ -403,13 +404,38 @@ const TOOLS = [
 async function main() {
     // Discover and load projects
     const projectDirs = discoverProjects();
-    const loader = new MultiLoader(projectDirs);
+    let loader = new MultiLoader(projectDirs);
     try {
         loader.load();
     }
     catch (err) {
         process.stderr.write(`Warning: ${err.message}\n`);
     }
+    // Auto-bootstrap: if no projects loaded, try to extract from CWD
+    if (!loader.isLoaded() && !process.env.SESHAT_PROJECTS) {
+        const cwd = process.cwd();
+        const seshatDir = path.join(cwd, '.seshat');
+        // Only bootstrap when .seshat/ doesn't exist at all (not corruption)
+        if (!fs.existsSync(seshatDir)) {
+            process.stderr.write(`[seshat-mcp] No .seshat/ found — attempting auto-bootstrap...\n`);
+            const result = await bootstrap(cwd);
+            if (result.success) {
+                // Re-create loader and retry
+                loader = new MultiLoader([cwd]);
+                try {
+                    loader.load();
+                    process.stderr.write(`[seshat-mcp] Auto-bootstrap succeeded: ${loader.totalEntities()} entities loaded\n`);
+                }
+                catch (err) {
+                    process.stderr.write(`[seshat-mcp] Auto-bootstrap produced files but load failed: ${err.message}\n`);
+                }
+            }
+            else {
+                process.stderr.write(`[seshat-mcp] Auto-bootstrap failed: ${result.error || 'unknown error'}\n`);
+                process.stderr.write(`[seshat-mcp] Starting with 0 entities. Run extraction manually or push to trigger CI.\n`);
+            }
+        }
+    }
     initTools(loader);
     // Build server name
     const projectNames = loader.getProjectNames();
@@ -428,7 +454,7 @@ async function main() {
     }
     const server = new Server({
         name: serverLabel,
-        version: '0.3.3',
+        version: '0.4.0',
     }, {
         capabilities: {
             tools: {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@papyruslabsai/seshat-mcp",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "description": "Semantic MCP server — exposes a codebase's 9D JSTF-T coordinate space as queryable tools",
   "type": "module",
   "bin": {