@papyruslabsai/seshat-mcp 0.14.2 → 0.15.0

package/dist/index.js

@@ -34,117 +34,17 @@ Use Seshat tools instead of grep/Read when you need to understand code structure
 All tools are read-only and safe to call speculatively — there is no cost to trying them.
 
 get_blast_radius and get_optimal_context are designed to be called iteratively. Start with any entity, then feed discovered entities back in to expand your understanding. Each round reveals new structure that informs where to look next. When answering "what does this system do?" questions, a few rounds of blast_radius → get_entity → blast_radius on the newly discovered symbols will build a complete picture faster than reading files.`;
-const TIER_ORDER = ['cartographer', 'pro', 'analyst', 'architect', 'founder'];
-const REVELATION_ORDER = ['core', 'navigate', 'security', 'quality', 'full'];
-// Which tools appear at each stage (cumulative — each stage includes all previous)
-const TOOL_REVELATION = {
-    // Always visible
-    get_account_status: 'core',
-    list_projects: 'core',
-    // Core loop — the curiosity engine (available immediately)
-    get_entity: 'core',
-    get_blast_radius: 'core',
-    get_dependencies: 'core',
-    get_optimal_context: 'core',
-    // Navigation — after agent starts exploring (revealed after ~3 queries)
-    query_entities: 'navigate',
-    list_modules: 'navigate',
-    get_topology: 'navigate',
-    get_data_flow: 'navigate',
-    find_by_constraint: 'navigate',
-    // Security surface — after architecture is understood (~8 queries)
-    get_auth_matrix: 'security',
-    find_exposure_leaks: 'security',
-    // Quality & audit — after deep exploration (~15 queries)
-    find_dead_code: 'quality',
-    find_layer_violations: 'quality',
-    get_coupling_metrics: 'quality',
-    find_error_gaps: 'quality',
-    get_test_coverage: 'quality',
-    find_runtime_violations: 'quality',
-    find_ownership_violations: 'quality',
-    query_traits: 'quality',
-    find_semantic_clones: 'quality',
-    // Architect — always gated by tier, shown when quality is visible
-    estimate_task_cost: 'full',
-    simulate_mutation: 'full',
-    create_symbol: 'full',
-    diff_bundle: 'full',
-    conflict_matrix: 'full',
-    query_data_targets: 'full',
-};
-// Query thresholds for each stage transition
-const REVELATION_THRESHOLDS = {
-    core: 0, // Immediate
-    navigate: 3, // After a few core loop calls
-    security: 8, // After architecture is understood
-    quality: 15, // After deep exploration
-    full: 25, // Power user territory
-};
-// Session state for progressive revelation
-let _sessionQueryCount = 0;
-let _currentStage = 'core';
-let _serverRef = null; // Stored so we can send notifications
-function stageAtLeast(current, required) {
-    return REVELATION_ORDER.indexOf(current) >= REVELATION_ORDER.indexOf(required);
-}
-function checkRevelation() {
-    for (const stage of REVELATION_ORDER) {
-        if (_sessionQueryCount >= REVELATION_THRESHOLDS[stage]) {
-            if (REVELATION_ORDER.indexOf(stage) > REVELATION_ORDER.indexOf(_currentStage)) {
-                const previousStage = _currentStage;
-                _currentStage = stage;
-                // Notify client that tool list has changed
-                if (_serverRef) {
-                    _serverRef.notification({ method: 'notifications/tools/list_changed' });
-                    process.stderr.write(`[Seshat] Revelation: ${previousStage} → ${stage} (${_sessionQueryCount} queries). Notified client.\n`);
-                }
-            }
-        }
-    }
-}
-const TOOL_TIERS = {
-    // Cartographer (free) — explore, navigate, and assess security surface
-    list_projects: 'cartographer',
-    query_entities: 'cartographer',
-    get_entity: 'cartographer',
-    get_dependencies: 'cartographer',
-    get_data_flow: 'cartographer',
-    find_by_constraint: 'cartographer',
-    get_blast_radius: 'cartographer',
-    list_modules: 'cartographer',
-    get_topology: 'cartographer',
-    get_optimal_context: 'cartographer',
-    get_auth_matrix: 'cartographer',
-    find_exposure_leaks: 'cartographer',
-    // Analyst (tier 2) — audit and diagnose
-    find_dead_code: 'analyst',
-    find_layer_violations: 'analyst',
-    get_coupling_metrics: 'analyst',
-    find_error_gaps: 'analyst',
-    get_test_coverage: 'analyst',
-    find_runtime_violations: 'analyst',
-    find_ownership_violations: 'analyst',
-    query_traits: 'analyst',
-    find_semantic_clones: 'analyst',
-    // Architect (tier 3) — simulate, estimate, and act
-    estimate_task_cost: 'architect',
-    simulate_mutation: 'architect',
-    create_symbol: 'architect',
-    diff_bundle: 'architect',
-    conflict_matrix: 'architect',
-    query_data_targets: 'architect',
-};
-const TIER_LABELS = {
-    cartographer: 'Cartographer (Free)',
-    pro: 'Seshat Pro',
-    analyst: 'Seshat Shield',
-    architect: 'Architect',
-    founder: 'Founder (All Access)',
-};
-function tierAtLeast(userTier, requiredTier) {
-    return TIER_ORDER.indexOf(userTier) >= TIER_ORDER.indexOf(requiredTier);
-}
+// ─── Private Tools (Ptah IP — never exposed publicly) ────────────
+// These tools are reserved for the Ptah write layer. They exist in
+// the codebase but are never listed, never hinted at, never mentioned.
+const PRIVATE_TOOLS = new Set([
+    'estimate_task_cost',
+    'simulate_mutation',
+    'create_symbol',
+    'diff_bundle',
+    'conflict_matrix',
+    'query_data_targets',
+]);
 // ─── Shared Definitions ──────────────────────────────────────────
 const projectParam = {
     type: 'string',
@@ -511,6 +411,11 @@ const TOOLS = [
         annotations: READ_ONLY_OPEN,
     },
 ];
+// ─── _meta Steering Hints ────────────────────────────────────────
+// After each tool call, suggest the next logical tool based on what
+// the agent has been doing. This replaces progressive revelation —
+// all tools are visible, but hints guide the agent toward the right
+// tool at the right time.
 // ─── Project Resolution (Fallback) ────────────────────────────────
 // Cache for the last project used — so tools auto-scope after list_projects
 let _lastKnownProject;
@@ -551,46 +456,15 @@ function getCloudUrl(path) {
 async function main() {
     const server = new Server({
         name: 'seshat',
-        version: '0.14.0',
+        version: '0.14.2',
     }, {
-        capabilities: { tools: { listChanged: true } },
+        capabilities: { tools: {} },
         instructions: SERVER_INSTRUCTIONS,
     });
-    // Store server ref for sending notifications from revelation system
-    _serverRef = server;
-    // ─── Dynamic ListTools — only expose tools the user can access ──
+    // ─── ListTools — all public tools, Architect tools hidden (Ptah IP) ──
     server.setRequestHandler(ListToolsRequestSchema, async () => {
-        const apiKey = process.env.SESHAT_API_KEY;
-        let userTier = 'cartographer';
-        // Fetch account status to determine which tools to expose
-        if (apiKey) {
-            try {
-                const res = await fetch(getCloudUrl('/api/mcp/account'), {
-                    method: 'GET',
-                    headers: { 'x-api-key': apiKey },
-                });
-                if (res.ok) {
-                    const account = await res.json();
-                    userTier = account.tier || 'cartographer';
-                }
-            }
-            catch {
-                // If unavailable, default to cartographer (free tier tools only)
-            }
-        }
-        // Filter tools by BOTH tier access AND revelation stage
-        const visibleTools = TOOLS.filter((tool) => {
-            // Tier gate: user must have access
-            const requiredTier = TOOL_TIERS[tool.name];
-            if (requiredTier && !tierAtLeast(userTier, requiredTier))
-                return false;
-            // Revelation gate: tool must be revealed at current stage
-            const requiredStage = TOOL_REVELATION[tool.name];
-            if (requiredStage && !stageAtLeast(_currentStage, requiredStage))
-                return false;
-            return true;
-        });
-        process.stderr.write(`[Seshat] ListTools: stage=${_currentStage}, queries=${_sessionQueryCount}, tools=${visibleTools.length}/${TOOLS.length}\n`);
+        const visibleTools = TOOLS.filter((tool) => !PRIVATE_TOOLS.has(tool.name));
+        process.stderr.write(`[Seshat] ListTools: ${visibleTools.length} tools (${PRIVATE_TOOLS.size} private)\n`);
         return { tools: visibleTools };
     });
     // ─── CallTool handler ──────────────────────────────────────────
@@ -603,6 +477,13 @@ async function main() {
                 isError: true,
             };
         }
+        // Block private Ptah tools from being called
+        if (PRIVATE_TOOLS.has(name)) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: `Unknown tool: ${name}` }, null, 2) }],
+                isError: true,
+            };
+        }
         // ─── get_account_status ──────────────────────────────────────
         if (name === 'get_account_status') {
             try {
@@ -618,37 +499,16 @@ async function main() {
                     };
                 }
                 const account = await res.json();
-                const userTier = account.tier || 'cartographer';
-                const credits = account.credits || 0;
-                // Build response: lead with what you CAN do, not what you can't
-                const availableTools = [];
-                const upgradeTeaser = {};
-                for (const [toolName, requiredTier] of Object.entries(TOOL_TIERS)) {
-                    if (tierAtLeast(userTier, requiredTier)) {
-                        availableTools.push(toolName);
-                    }
-                    else {
-                        if (!upgradeTeaser[TIER_LABELS[requiredTier]]) {
-                            upgradeTeaser[TIER_LABELS[requiredTier]] = [];
-                        }
-                        upgradeTeaser[TIER_LABELS[requiredTier]].push(toolName);
-                    }
-                }
+                // List all public tools
+                const publicTools = TOOLS
+                    .filter(t => !PRIVATE_TOOLS.has(t.name))
+                    .map(t => t.name);
                 const response = {
-                    tier: userTier,
-                    tier_label: TIER_LABELS[userTier],
-                    ptah_credits: credits,
-                    your_tools: availableTools,
-                    tool_count: `${availableTools.length} tools available`,
+                    status: 'active',
+                    tools_available: publicTools.length,
+                    your_tools: publicTools,
+                    dashboard: 'https://ptah.papyruslabs.ai/dashboard',
                 };
-                // Only mention upgrades if there are locked tools, and frame positively
-                if (Object.keys(upgradeTeaser).length > 0) {
-                    const totalLocked = Object.values(upgradeTeaser).reduce((sum, t) => sum + t.length, 0);
-                    response.upgrades_available = {
-                        summary: `${totalLocked} additional diagnostic and simulation tools available with a tier upgrade — find dead code, coupling hotspots, test gaps, layer violations, and simulate changes before making them.`,
-                        url: 'https://ptah.papyruslabs.ai/settings/billing',
-                    };
-                }
                 return {
                     content: [{ type: 'text', text: JSON.stringify(response, null, 2) }],
                 };
@@ -702,12 +562,10 @@ async function main() {
             if (name === 'list_projects' && result.projects && result.projects.length > 0) {
                 _lastKnownProject = result.projects[0].name;
             }
-            // Progressive revelation: count queries and check for stage transitions
-            _sessionQueryCount++;
-            checkRevelation();
             // Separate _meta into assistant-only content so it doesn't clutter
             // the user-visible response. The LLM still sees it for context.
-            if (result._meta) {
+            // Server-side _meta now includes cross-tool recommendations.
+            if (result._meta && Object.keys(result._meta).length > 0) {
                 const meta = result._meta;
                 delete result._meta;
                 return {
@@ -717,6 +575,9 @@ async function main() {
                     ],
                 };
             }
+            // Strip empty _meta
+            if (result._meta)
+                delete result._meta;
             return {
                 content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
             };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@papyruslabsai/seshat-mcp",
-  "version": "0.14.2",
+  "version": "0.15.0",
   "description": "Semantic MCP server — exposes a codebase's structure, dependencies, and constraints as queryable tools",
   "type": "module",
   "bin": {