@papyruslabsai/seshat-mcp 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -3,22 +3,37 @@
  * @papyruslabs/seshat-mcp — Semantic MCP Server
  *
  * Exposes a codebase's 9D JSTF-T coordinate space as queryable MCP tools.
- * Reads .seshat/_bundle.json from the current working directory.
+ * Reads .seshat/_bundle.json from project directories.
  *
- * Tools:
- *   query_entities    — Search entities by name, layer, module, language
- *   get_entity        — Full 9D coordinate dump for one entity
- *   get_dependencies  — ε edge traversal (callers/callees with depth control)
- *   get_data_flow     — δ dimension: inputs, outputs, mutations
- *   find_by_constraint — κ dimension search (AUTH, THROWS, DB_ACCESS, etc.)
- *   get_blast_radius  — Theorem 9.4: affected set for given entity IDs
- *   list_modules      — Group entities by layer, module, file, or language
- *   get_topology      — API topology (routes, plugins, auth, tables)
+ * Multi-project mode:
+ *   Set SESHAT_PROJECTS env var to comma-separated paths or a glob pattern.
+ *   In multi-project mode, all tools require a `project` parameter.
+ *   Use `list_projects` to see available projects.
  *
- * Usage:
- *   npx @papyruslabs/seshat-mcp
+ * Single-project mode (default):
+ *   When SESHAT_PROJECTS is not set, loads from CWD. No `project` param needed.
+ *
+ * Tools (8 core + 7 interpretation functors + 1 meta):
+ *   list_projects       — Show loaded projects with entity counts
+ *   query_entities      — Search entities by name, layer, module, language
+ *   get_entity          — Full 9D coordinate dump for one entity
+ *   get_dependencies    — ε edge traversal (callers/callees with depth control)
+ *   get_data_flow       — δ dimension: inputs, outputs, mutations
+ *   find_by_constraint  — κ dimension search (AUTH, THROWS, DB_ACCESS, etc.)
+ *   get_blast_radius    — Theorem 9.4: affected set for given entity IDs
+ *   list_modules        — Group entities by layer, module, file, or language
+ *   get_topology        — API topology (routes, plugins, auth, tables)
+ *   find_dead_code      — Unreachable entities via ε-graph BFS
+ *   find_layer_violations — ε edges violating architectural layer ordering
+ *   get_coupling_metrics  — Module coupling/cohesion/instability from ε-graph
+ *   get_auth_matrix       — Auth coverage across API-facing entities from κ
+ *   find_error_gaps       — Fallible callees whose callers lack try/catch
+ *   get_test_coverage     — Entities exercised by tests vs uncovered
+ *   get_optimal_context   — Greedy knapsack: max relevance per token for LLM context
  *
- * Configure in Claude Code (~/.claude/settings.json):
- *   { "mcpServers": { "seshat": { "command": "npx", "args": ["@papyruslabs/seshat-mcp"] } } }
+ * Usage:
+ *   npx @papyruslabs/seshat-mcp                           # single project (CWD)
+ *   SESHAT_PROJECTS=/path/a,/path/b npx @papyruslabs/seshat-mcp  # multi-project
+ *   SESHAT_PROJECTS="/home/user/projects/*" npx @papyruslabs/seshat-mcp  # glob
  */
 export {};

package/dist/index.js

@@ -3,37 +3,109 @@
  * @papyruslabs/seshat-mcp — Semantic MCP Server
  *
  * Exposes a codebase's 9D JSTF-T coordinate space as queryable MCP tools.
- * Reads .seshat/_bundle.json from the current working directory.
+ * Reads .seshat/_bundle.json from project directories.
  *
- * Tools:
- *   query_entities    — Search entities by name, layer, module, language
- *   get_entity        — Full 9D coordinate dump for one entity
- *   get_dependencies  — ε edge traversal (callers/callees with depth control)
- *   get_data_flow     — δ dimension: inputs, outputs, mutations
- *   find_by_constraint — κ dimension search (AUTH, THROWS, DB_ACCESS, etc.)
- *   get_blast_radius  — Theorem 9.4: affected set for given entity IDs
- *   list_modules      — Group entities by layer, module, file, or language
- *   get_topology      — API topology (routes, plugins, auth, tables)
+ * Multi-project mode:
+ *   Set SESHAT_PROJECTS env var to comma-separated paths or a glob pattern.
+ *   In multi-project mode, all tools require a `project` parameter.
+ *   Use `list_projects` to see available projects.
  *
- * Usage:
- *   npx @papyruslabs/seshat-mcp
+ * Single-project mode (default):
+ *   When SESHAT_PROJECTS is not set, loads from CWD. No `project` param needed.
+ *
+ * Tools (8 core + 7 interpretation functors + 1 meta):
+ *   list_projects       — Show loaded projects with entity counts
+ *   query_entities      — Search entities by name, layer, module, language
+ *   get_entity          — Full 9D coordinate dump for one entity
+ *   get_dependencies    — ε edge traversal (callers/callees with depth control)
+ *   get_data_flow       — δ dimension: inputs, outputs, mutations
+ *   find_by_constraint  — κ dimension search (AUTH, THROWS, DB_ACCESS, etc.)
+ *   get_blast_radius    — Theorem 9.4: affected set for given entity IDs
+ *   list_modules        — Group entities by layer, module, file, or language
+ *   get_topology        — API topology (routes, plugins, auth, tables)
+ *   find_dead_code      — Unreachable entities via ε-graph BFS
+ *   find_layer_violations — ε edges violating architectural layer ordering
+ *   get_coupling_metrics  — Module coupling/cohesion/instability from ε-graph
+ *   get_auth_matrix       — Auth coverage across API-facing entities from κ
+ *   find_error_gaps       — Fallible callees whose callers lack try/catch
+ *   get_test_coverage     — Entities exercised by tests vs uncovered
+ *   get_optimal_context   — Greedy knapsack: max relevance per token for LLM context
  *
- * Configure in Claude Code (~/.claude/settings.json):
- *   { "mcpServers": { "seshat": { "command": "npx", "args": ["@papyruslabs/seshat-mcp"] } } }
+ * Usage:
+ *   npx @papyruslabs/seshat-mcp                           # single project (CWD)
+ *   SESHAT_PROJECTS=/path/a,/path/b npx @papyruslabs/seshat-mcp  # multi-project
+ *   SESHAT_PROJECTS="/home/user/projects/*" npx @papyruslabs/seshat-mcp  # glob
  */
+import fs from 'fs';
+import path from 'path';
 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 { BundleLoader } from './loader.js';
+import { MultiLoader } from './loader.js';
 import { initTools, queryEntities, getEntity, getDependencies, getDataFlow, findByConstraint, getBlastRadius, listModules, getTopology, } from './tools/index.js';
+import { findDeadCode, findLayerViolations, getCouplingMetrics, getAuthMatrix, findErrorGaps, getTestCoverage, getOptimalContext, } from './tools/functors.js';
+// ─── Project Discovery ───────────────────────────────────────────
+/**
+ * Discover project directories from SESHAT_PROJECTS env var.
+ *
+ * - Not set → [process.cwd()] (backward compat)
+ * - Comma-separated paths → resolve each
+ * - Glob pattern (contains *) → scan parent dir for subdirs with .seshat/_bundle.json
+ */
+function discoverProjects() {
+    const env = process.env.SESHAT_PROJECTS;
+    if (!env)
+        return [process.cwd()];
+    const trimmed = env.trim();
+    // Glob pattern: /path/to/projects/*
+    if (trimmed.includes('*')) {
+        const globDir = trimmed.replace(/\/?\*$/, '');
+        const resolved = path.resolve(globDir);
+        if (!fs.existsSync(resolved)) {
+            process.stderr.write(`SESHAT_PROJECTS glob dir not found: ${resolved}\n`);
+            return [process.cwd()];
+        }
+        const dirs = [];
+        for (const entry of fs.readdirSync(resolved, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const candidate = path.join(resolved, entry.name);
+            const bundlePath = path.join(candidate, '.seshat', '_bundle.json');
+            if (fs.existsSync(bundlePath)) {
+                dirs.push(candidate);
+            }
+        }
+        if (dirs.length === 0) {
+            process.stderr.write(`SESHAT_PROJECTS: no dirs with .seshat/_bundle.json found in ${resolved}\n`);
+            return [process.cwd()];
+        }
+        return dirs;
+    }
+    // Comma-separated paths
+    return trimmed.split(',').map(p => path.resolve(p.trim())).filter(p => p.length > 0);
+}
+// ─── Project param definition (injected into all tool schemas) ───
+const projectParam = {
+    type: 'string',
+    description: 'Project name (required in multi-project mode). Use list_projects to see available projects.',
+};
 // ─── Tool Definitions ─────────────────────────────────────────────
 const TOOLS = [
+    {
+        name: 'list_projects',
+        description: 'List all loaded projects with entity counts, languages, and metadata. Call this first to see what projects are available, then pass the project name to other tools.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
     {
         name: 'query_entities',
         description: 'Search entities in the 9D semantic coordinate space. Filter by name, architectural layer (route/service/repository/component), module, or source language. Returns entity summaries with constraint tags.',
         inputSchema: {
             type: 'object',
             properties: {
+                project: projectParam,
                 query: {
                     type: 'string',
                     description: 'Search term — matches against entity name, ID, source file, and module',
@@ -63,6 +135,7 @@ const TOOLS = [
         inputSchema: {
             type: 'object',
             properties: {
+                project: projectParam,
                 id: {
                     type: 'string',
                     description: 'Entity ID or name',
@@ -77,6 +150,7 @@ const TOOLS = [
         inputSchema: {
             type: 'object',
             properties: {
+                project: projectParam,
                 entity_id: {
                     type: 'string',
                     description: 'Entity ID or name',
@@ -100,6 +174,7 @@ const TOOLS = [
         inputSchema: {
             type: 'object',
             properties: {
+                project: projectParam,
                 entity_id: {
                     type: 'string',
                     description: 'Entity ID or name',
@@ -114,6 +189,7 @@ const TOOLS = [
         inputSchema: {
             type: 'object',
             properties: {
+                project: projectParam,
                 constraint: {
                     type: 'string',
                     description: 'Constraint tag to search for: AUTH, VALIDATED, PURE, THROWS, DB_ACCESS, NETWORK_IO, IMP, etc.',
@@ -128,6 +204,7 @@ const TOOLS = [
         inputSchema: {
             type: 'object',
             properties: {
+                project: projectParam,
                 entity_ids: {
                     type: 'array',
                     items: { type: 'string' },
@@ -143,6 +220,7 @@ const TOOLS = [
         inputSchema: {
             type: 'object',
             properties: {
+                project: projectParam,
                 group_by: {
                     type: 'string',
                     enum: ['layer', 'module', 'file', 'language'],
@@ -156,28 +234,140 @@ const TOOLS = [
         description: 'Get the API topology: routes, plugins, auth patterns, and database tables. Built from the χ (context) and ε (edges) dimensions across all entities.',
         inputSchema: {
             type: 'object',
-            properties: {},
+            properties: {
+                project: projectParam,
+            },
+        },
+    },
+    // ─── Interpretation Functor Tools ────────────────────────────────
+    {
+        name: 'find_dead_code',
+        description: 'Find unreachable entities (dead code candidates). BFS from entry points (routes, exported functions, tests, plugins) through the ε call graph. Entities not reachable from any entry point are flagged.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: projectParam,
+                include_tests: {
+                    type: 'boolean',
+                    description: 'Include test entities in dead code results (default: false)',
+                },
+            },
+        },
+    },
+    {
+        name: 'find_layer_violations',
+        description: 'Detect architectural layer violations in the ε call graph. Finds backward calls (lower layer calling higher layer, e.g. repository → route) and skip-layer calls (jumping over multiple layers). Uses χ.layer for classification.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: projectParam,
+            },
+        },
+    },
+    {
+        name: 'get_coupling_metrics',
+        description: 'Compute coupling, cohesion, and instability metrics for modules or layers. Analyzes ε edges between and within groups. High coupling + low cohesion = candidates for refactoring.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: projectParam,
+                group_by: {
+                    type: 'string',
+                    enum: ['module', 'layer'],
+                    description: 'Group entities by module or layer (default: module)',
+                },
+            },
+        },
+    },
+    {
+        name: 'get_auth_matrix',
+        description: 'Analyze authentication coverage across all API-facing entities. Shows which routes/controllers have auth requirements (from κ.auth) and which don\'t. Detects inconsistencies like DB access without auth.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: projectParam,
+            },
+        },
+    },
+    {
+        name: 'find_error_gaps',
+        description: 'Find error handling gaps: fallible entities (κ.throws, network/db side effects) whose callers lack try/catch (κ.errorHandling). These are crash risk points where exceptions can propagate unhandled.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: projectParam,
+            },
+        },
+    },
+    {
+        name: 'get_test_coverage',
+        description: 'Compute semantic test coverage: which production entities are exercised by test entities via the ε call graph. Optionally weight uncovered entities by blast radius to prioritize what to test first.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: projectParam,
+                weight_by_blast_radius: {
+                    type: 'boolean',
+                    description: 'Rank uncovered entities by blast radius to prioritize testing (default: false, slower)',
+                },
+            },
+        },
+    },
+    {
+        name: 'get_optimal_context',
+        description: 'Compute the optimal set of related entities to include in an LLM context window for a target entity. Uses greedy knapsack: maximizes relevance per token. Returns entities ranked by relevance with token estimates.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: projectParam,
+                target_entity: {
+                    type: 'string',
+                    description: 'Entity ID or name to build context around',
+                },
+                max_tokens: {
+                    type: 'number',
+                    description: 'Token budget for the context window (default: 8000)',
+                },
+                strategy: {
+                    type: 'string',
+                    enum: ['bfs', 'blast_radius'],
+                    description: 'Traversal strategy: bfs (faster, local neighborhood) or blast_radius (full affected set)',
+                },
+            },
+            required: ['target_entity'],
         },
     },
 ];
 // ─── Server Setup ─────────────────────────────────────────────────
 async function main() {
-    // Load the JSTF-T bundle
-    const loader = new BundleLoader();
+    // Discover and load projects
+    const projectDirs = discoverProjects();
+    const loader = new MultiLoader(projectDirs);
     try {
         loader.load();
     }
     catch (err) {
-        // Server will start but tools will return helpful errors
         process.stderr.write(`Warning: ${err.message}\n`);
     }
     initTools(loader);
-    const manifest = loader.isLoaded() ? loader.getManifest() : null;
-    const projectName = manifest?.projectName || 'unknown';
-    const entityCount = manifest?.entityCount || 0;
+    // Build server name
+    const projectNames = loader.getProjectNames();
+    const totalEntities = loader.totalEntities();
+    const isMulti = loader.isMultiProject();
+    let serverLabel;
+    if (!loader.isLoaded()) {
+        serverLabel = 'seshat-mcp (no projects loaded)';
+    }
+    else if (isMulti) {
+        serverLabel = `seshat-mcp (${projectNames.length} projects, ${totalEntities} entities)`;
+    }
+    else {
+        const manifest = loader.getManifest();
+        serverLabel = `seshat-mcp (${manifest?.projectName || projectNames[0] || 'unknown'})`;
+    }
     const server = new Server({
-        name: `seshat-mcp (${projectName})`,
-        version: '0.1.0',
+        name: serverLabel,
+        version: '0.3.0',
     }, {
         capabilities: {
             tools: {},
@@ -196,13 +386,25 @@ async function main() {
                     content: [{
                             type: 'text',
                             text: JSON.stringify({
-                                error: 'No .seshat/_bundle.json found in the current working directory. Run the Seshat extraction pipeline first.',
+                                error: 'No projects loaded. Ensure .seshat/_bundle.json exists or set SESHAT_PROJECTS env var.',
                             }, null, 2),
                         }],
                 };
             }
             let result;
             switch (name) {
+                // Meta
+                case 'list_projects':
+                    result = {
+                        multiProject: isMulti,
+                        projects: loader.getProjectInfo(),
+                        totalEntities,
+                        hint: isMulti
+                            ? 'Pass the project name as the "project" parameter to all other tools.'
+                            : 'Single project mode — the "project" parameter is optional.',
+                    };
+                    break;
+                // Core tools
                 case 'query_entities':
                     result = queryEntities(args);
                     break;
@@ -225,7 +427,29 @@ async function main() {
                     result = listModules(args);
                     break;
                 case 'get_topology':
-                    result = getTopology();
+                    result = getTopology(args);
+                    break;
+                // Interpretation Functors
+                case 'find_dead_code':
+                    result = findDeadCode(args);
+                    break;
+                case 'find_layer_violations':
+                    result = findLayerViolations(args);
+                    break;
+                case 'get_coupling_metrics':
+                    result = getCouplingMetrics(args);
+                    break;
+                case 'get_auth_matrix':
+                    result = getAuthMatrix(args);
+                    break;
+                case 'find_error_gaps':
+                    result = findErrorGaps(args);
+                    break;
+                case 'get_test_coverage':
+                    result = getTestCoverage(args);
+                    break;
+                case 'get_optimal_context':
+                    result = getOptimalContext(args);
                     break;
                 default:
                     result = { error: `Unknown tool: ${name}` };
@@ -252,7 +476,13 @@ async function main() {
     // Start stdio transport
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    process.stderr.write(`Seshat MCP server started: ${projectName} (${entityCount} entities)\n`);
+    if (isMulti) {
+        process.stderr.write(`Seshat MCP server started: ${projectNames.length} projects (${totalEntities} entities) — ${projectNames.join(', ')}\n`);
+    }
+    else {
+        const manifest = loader.getManifest();
+        process.stderr.write(`Seshat MCP server started: ${manifest?.projectName || 'unknown'} (${totalEntities} entities)\n`);
+    }
 }
 main().catch((err) => {
     process.stderr.write(`Fatal: ${err.message}\n`);

package/dist/loader.d.ts

@@ -4,7 +4,7 @@
  * Discovers and loads .seshat/_bundle.json from the current working directory.
  * Falls back to checking common alternative locations.
  */
-import type { JstfEntity, Topology, Manifest } from './types.js';
+import type { JstfEntity, Topology, Manifest, ProjectInfo } from './types.js';
 export declare class BundleLoader {
     private entities;
     private topology;
@@ -20,3 +20,31 @@ export declare class BundleLoader {
     getEntityByName(name: string): JstfEntity | undefined;
     isLoaded(): boolean;
 }
+/**
+ * Wraps N BundleLoader instances for multi-project access.
+ * In single-project mode (1 dir), behaves identically to BundleLoader.
+ * In multi-project mode, `project` param is required on all accessors.
+ */
+export declare class MultiLoader {
+    private projects;
+    private projectPaths;
+    private projectEntities;
+    private loaded;
+    private dirs;
+    constructor(projectDirs: string[]);
+    load(): void;
+    /** Get the resolved project name when only one project is loaded. */
+    private defaultProject;
+    private resolveProject;
+    getEntities(project?: string): JstfEntity[];
+    getTopology(project?: string): Topology | null;
+    getManifest(project?: string): Manifest | null;
+    getEntityById(id: string, project?: string): JstfEntity | undefined;
+    getEntityByName(name: string, project?: string): JstfEntity | undefined;
+    getProjectNames(): string[];
+    getProjectInfo(): ProjectInfo[];
+    isMultiProject(): boolean;
+    isLoaded(): boolean;
+    hasProject(name: string): boolean;
+    totalEntities(): number;
+}

package/dist/loader.js

@@ -67,3 +67,122 @@ export class BundleLoader {
         return this.loaded;
     }
 }
+// ─── Multi-Project Loader ─────────────────────────────────────────
+/**
+ * Wraps N BundleLoader instances for multi-project access.
+ * In single-project mode (1 dir), behaves identically to BundleLoader.
+ * In multi-project mode, `project` param is required on all accessors.
+ */
+export class MultiLoader {
+    projects = new Map();
+    projectPaths = new Map();
+    projectEntities = new Map();
+    loaded = false;
+    dirs;
+    constructor(projectDirs) {
+        this.dirs = projectDirs.length > 0 ? projectDirs : [process.cwd()];
+    }
+    load() {
+        for (const dir of this.dirs) {
+            const loader = new BundleLoader(dir);
+            try {
+                loader.load();
+                const manifest = loader.getManifest();
+                const name = manifest?.projectName || path.basename(dir);
+                this.projects.set(name, loader);
+                this.projectPaths.set(name, dir);
+                // Stamp entities with _project
+                const entities = loader.getEntities();
+                for (const e of entities) {
+                    e._project = name;
+                }
+                this.projectEntities.set(name, entities);
+            }
+            catch (err) {
+                process.stderr.write(`Warning: Skipping ${dir}: ${err.message}\n`);
+            }
+        }
+        this.loaded = true;
+    }
+    /** Get the resolved project name when only one project is loaded. */
+    defaultProject() {
+        if (this.projects.size === 1)
+            return [...this.projects.keys()][0];
+        return undefined;
+    }
+    resolveProject(project) {
+        return project || this.defaultProject();
+    }
+    getEntities(project) {
+        if (!this.loaded)
+            this.load();
+        const p = this.resolveProject(project);
+        if (p)
+            return this.projectEntities.get(p) || [];
+        return []; // multi-project with no project specified
+    }
+    getTopology(project) {
+        if (!this.loaded)
+            this.load();
+        const p = this.resolveProject(project);
+        if (p)
+            return this.projects.get(p)?.getTopology() || null;
+        return null;
+    }
+    getManifest(project) {
+        if (!this.loaded)
+            this.load();
+        const p = this.resolveProject(project);
+        if (p)
+            return this.projects.get(p)?.getManifest() || null;
+        return null;
+    }
+    getEntityById(id, project) {
+        return this.getEntities(project).find(e => e.id === id);
+    }
+    getEntityByName(name, project) {
+        return this.getEntities(project).find(e => {
+            const structName = typeof e.struct === 'string' ? e.struct : e.struct?.name;
+            return e.id === name || structName === name;
+        });
+    }
+    getProjectNames() {
+        if (!this.loaded)
+            this.load();
+        return [...this.projects.keys()];
+    }
+    getProjectInfo() {
+        if (!this.loaded)
+            this.load();
+        const result = [];
+        for (const [name, loader] of this.projects) {
+            const manifest = loader.getManifest();
+            result.push({
+                name,
+                path: this.projectPaths.get(name) || '',
+                entityCount: loader.getEntities().length,
+                languages: manifest?.languages || [],
+                commitSha: manifest?.commitSha || '',
+                extractedAt: manifest?.extractedAt || '',
+                layers: manifest?.layers || {},
+            });
+        }
+        return result;
+    }
+    isMultiProject() {
+        return this.projects.size > 1;
+    }
+    isLoaded() {
+        return this.loaded && this.projects.size > 0;
+    }
+    hasProject(name) {
+        return this.projects.has(name);
+    }
+    totalEntities() {
+        let total = 0;
+        for (const entities of this.projectEntities.values()) {
+            total += entities.length;
+        }
+        return total;
+    }
+}

package/dist/tools/functors.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Interpretation Functor Tools
+ *
+ * Each functor is I: J -> D — projecting the 9D JSTF-T coordinate space
+ * onto a domain-specific judgment. These are composite analyses built
+ * from the primitive dimensions (sigma, epsilon, delta, kappa, chi, tau, rho).
+ */
+export declare function findDeadCode(args: {
+    include_tests?: boolean;
+    project?: string;
+}): unknown;
+export declare function findLayerViolations(args?: {
+    project?: string;
+}): unknown;
+export declare function getCouplingMetrics(args: {
+    group_by?: 'module' | 'layer';
+    project?: string;
+}): unknown;
+export declare function getAuthMatrix(args?: {
+    project?: string;
+}): unknown;
+export declare function findErrorGaps(args?: {
+    project?: string;
+}): unknown;
+export declare function getTestCoverage(args: {
+    weight_by_blast_radius?: boolean;
+    project?: string;
+}): unknown;
+export declare function getOptimalContext(args: {
+    target_entity: string;
+    max_tokens?: number;
+    strategy?: 'bfs' | 'blast_radius';
+    project?: string;
+}): unknown;