@papyruslabsai/seshat-mcp 0.20.0 → 0.20.1

package/dist/supabase.d.ts

@@ -1,99 +0,0 @@
-/**
- * Lightweight Supabase REST client for the calibration feedback loop.
- *
- * Uses Node 20+ native fetch — zero external dependencies.
- * Gracefully degrades: if SESHAT_SUPABASE_URL / SESHAT_SUPABASE_KEY are not set,
- * all operations silently no-op so the MCP server works offline.
- *
- * Environment variables (checks both prefixed and standard names):
- *   SUPABASE_URL                — e.g. https://nlsrjceluztfllbqfpkm.supabase.co
- *   SUPABASE_SERVICE_ROLE_KEY   — service_role key (preferred)
- *   SESHAT_SUPABASE_URL         — override (optional)
- *   SESHAT_SUPABASE_KEY         — override (optional)
- */
-/** Whether Supabase logging is available. */
-export declare function isSupabaseConfigured(): boolean;
-export interface TokenPredictionInsert {
-    project: string;
-    target_entities: string[];
-    predicted_context_load: number;
-    predicted_iteration_mult: number;
-    predicted_total: number;
-    affected_entities: number;
-    affected_files: number;
-    affected_layers: string[];
-    estimator_used: 'syntactic' | 'charDiv4' | 'heuristic';
-    context_budget: number;
-    session_id?: string;
-}
-export interface ActualBurnUpdate {
-    actual_input_tokens: number;
-    actual_output_tokens: number;
-    actual_total_tokens: number;
-    model: string;
-    notes?: string;
-}
-export interface TokenPredictionRow {
-    id: string;
-    created_at: string;
-    project: string;
-    target_entities: string[];
-    predicted_context_load: number;
-    predicted_iteration_mult: number;
-    predicted_total: number;
-    affected_entities: number;
-    affected_files: number;
-    affected_layers: string[];
-    estimator_used: string;
-    context_budget: number;
-    actual_input_tokens: number | null;
-    actual_output_tokens: number | null;
-    actual_total_tokens: number | null;
-    model: string | null;
-    drift_ratio: number | null;
-    status: string;
-    session_id: string | null;
-    notes: string | null;
-}
-export interface McpTelemetryLog {
-    user_id?: string;
-    tool_name: string;
-    project_hash: string;
-    execution_ms: number;
-}
-export interface JstfSnapshotInsert {
-    user_id?: string;
-    project_hash: string;
-    commit_sha: string;
-    language_primary: string;
-    total_entities: number;
-    metric_typeless_interfaces: number;
-    metric_max_in_degree: number;
-    metric_circular_dependencies: number;
-    metric_untracked_data_transformations: number;
-    metric_exposure_leaks: number;
-    metric_layer_violations: number;
-    metric_ownership_violations: number;
-    metric_impure_ratio: number;
-    metric_runtime_violations: number;
-    metric_semantic_clones: number;
-    metric_core_fragility_score: number;
-    bundle_payload: unknown;
-}
-/**
- * Insert a prediction row. Returns the row ID or null on failure.
- */
-export declare function insertPrediction(row: TokenPredictionInsert): Promise<string | null>;
-/**
- * Report actual token burn for a prediction. Computes drift and sets status=completed.
- */
-export declare function updateActualBurn(predictionId: string, actual: ActualBurnUpdate): Promise<TokenPredictionRow | null>;
-/**
- * Abandon a prediction (task was cancelled or not completed).
- */
-export declare function abandonPrediction(predictionId: string): Promise<boolean>;
-/**
- * List recent predictions for a project (for calibration analysis).
- */
-export declare function logTelemetry(log: McpTelemetryLog): Promise<void>;
-export declare function insertJstfSnapshot(snapshot: JstfSnapshotInsert): Promise<boolean>;

package/dist/supabase.js

@@ -1,132 +0,0 @@
-/**
- * Lightweight Supabase REST client for the calibration feedback loop.
- *
- * Uses Node 20+ native fetch — zero external dependencies.
- * Gracefully degrades: if SESHAT_SUPABASE_URL / SESHAT_SUPABASE_KEY are not set,
- * all operations silently no-op so the MCP server works offline.
- *
- * Environment variables (checks both prefixed and standard names):
- *   SUPABASE_URL                — e.g. https://nlsrjceluztfllbqfpkm.supabase.co
- *   SUPABASE_SERVICE_ROLE_KEY   — service_role key (preferred)
- *   SESHAT_SUPABASE_URL         — override (optional)
- *   SESHAT_SUPABASE_KEY         — override (optional)
- */
-const SUPABASE_URL = (process.env.SESHAT_SUPABASE_URL || process.env.SUPABASE_URL || '').replace(/\/$/, '');
-const SUPABASE_KEY = process.env.SESHAT_SUPABASE_KEY || process.env.SUPABASE_SERVICE_ROLE_KEY || '';
-/** Whether Supabase logging is available. */
-export function isSupabaseConfigured() {
-    return SUPABASE_URL.length > 0 && SUPABASE_KEY.length > 0;
-}
-// ─── REST helpers ────────────────────────────────────────────────
-const TABLE_PREDICTIONS = 'mcp_token_predictions';
-const TABLE_TELEMETRY = 'mcp_telemetry_logs';
-const TABLE_SNAPSHOTS = 'jstf_snapshots';
-async function supabaseRequest(method, path, body, headers) {
-    if (!isSupabaseConfigured()) {
-        return { ok: false, status: 0, error: 'Supabase not configured' };
-    }
-    const url = `${SUPABASE_URL}/rest/v1/${path}`;
-    const reqHeaders = {
-        'apikey': SUPABASE_KEY,
-        'Authorization': `Bearer ${SUPABASE_KEY}`,
-        'Content-Type': 'application/json',
-        'Prefer': 'return=representation',
-        ...headers,
-    };
-    try {
-        const res = await fetch(url, {
-            method,
-            headers: reqHeaders,
-            body: body ? JSON.stringify(body) : undefined,
-        });
-        const text = await res.text();
-        let data;
-        try {
-            data = JSON.parse(text);
-        }
-        catch {
-            data = text;
-        }
-        if (!res.ok) {
-            return { ok: false, status: res.status, error: `${res.status}: ${text}` };
-        }
-        return { ok: true, status: res.status, data };
-    }
-    catch (err) {
-        return { ok: false, status: 0, error: err.message };
-    }
-}
-// ─── Public API ──────────────────────────────────────────────────
-/**
- * Insert a prediction row. Returns the row ID or null on failure.
- */
-export async function insertPrediction(row) {
-    const result = await supabaseRequest('POST', TABLE_PREDICTIONS, row);
-    if (!result.ok) {
-        process.stderr.write(`[seshat] Prediction log failed: ${result.error}\n`);
-        return null;
-    }
-    const rows = result.data;
-    return rows?.[0]?.id ?? null;
-}
-/**
- * Report actual token burn for a prediction. Computes drift and sets status=completed.
- */
-export async function updateActualBurn(predictionId, actual) {
-    // First fetch the prediction to compute drift
-    const fetchResult = await supabaseRequest('GET', `${TABLE_PREDICTIONS}?id=eq.${predictionId}&select=predicted_total,status`);
-    if (!fetchResult.ok) {
-        process.stderr.write(`[seshat] Fetch prediction failed: ${fetchResult.error}\n`);
-        return null;
-    }
-    const rows = fetchResult.data;
-    if (!rows || rows.length === 0) {
-        return null; // not found
-    }
-    const predicted = rows[0];
-    if (predicted.status !== 'predicted') {
-        return null; // already completed or abandoned
-    }
-    // Compute drift ratio
-    const driftRatio = predicted.predicted_total > 0
-        ? Math.round(((actual.actual_total_tokens - predicted.predicted_total) / predicted.predicted_total) * 1000) / 1000
-        : null;
-    const updateBody = {
-        actual_input_tokens: actual.actual_input_tokens,
-        actual_output_tokens: actual.actual_output_tokens,
-        actual_total_tokens: actual.actual_total_tokens,
-        model: actual.model,
-        drift_ratio: driftRatio,
-        status: 'completed',
-        ...(actual.notes ? { notes: actual.notes } : {}),
-    };
-    const updateResult = await supabaseRequest('PATCH', `${TABLE_PREDICTIONS}?id=eq.${predictionId}`, updateBody);
-    if (!updateResult.ok) {
-        process.stderr.write(`[seshat] Update actual burn failed: ${updateResult.error}\n`);
-        return null;
-    }
-    return updateResult.data?.[0] ?? null;
-}
-/**
- * Abandon a prediction (task was cancelled or not completed).
- */
-export async function abandonPrediction(predictionId) {
-    const result = await supabaseRequest('PATCH', `${TABLE_PREDICTIONS}?id=eq.${predictionId}&status=eq.predicted`, { status: 'abandoned' });
-    return result.ok;
-}
-/**
- * List recent predictions for a project (for calibration analysis).
- */
-export async function logTelemetry(log) {
-    const result = await supabaseRequest('POST', TABLE_TELEMETRY, log);
-    if (!result.ok) {
-        process.stderr.write(`[seshat] Telemetry log failed: ${result.error}\n`);
-    }
-}
-export async function insertJstfSnapshot(snapshot) {
-    const result = await supabaseRequest('POST', TABLE_SNAPSHOTS, snapshot);
-    if (!result.ok) {
-        process.stderr.write(`[seshat] JSTF snapshot failed: ${result.error}\n`);
-    }
-    return result.ok;
-}

package/dist/tools/dbops.d.ts

@@ -1,24 +0,0 @@
-/**
- * Database operation extraction from entity coordinates.
- *
- * Parses Supabase/Prisma call targets in the edge set and db statements in
- * the semantics dimension to answer: which tables does this entity read or
- * write? This is the δ-contract surface that conflict_matrix uses to detect
- * tasks that collide through shared data even when their symbols and files
- * are disjoint (the "spawner oscillation" class of conflict).
- *
- * Ported from apps/api/routes/mcp.js extractDbOperations so the package's
- * own tools (conflict_matrix) can use it without the cloud layer.
- */
-import type { JstfEntity } from '../types.js';
-export interface DbOperation {
-    table: string;
-    operation: string;
-    type: 'db_query' | 'db_mutate';
-}
-export declare function extractDbOps(entity: JstfEntity): DbOperation[];
-/** Aggregate db ops for a set of entities into read/write table sets. */
-export declare function tableContract(entities: JstfEntity[]): {
-    reads: Set<string>;
-    writes: Set<string>;
-};

package/dist/tools/dbops.js

@@ -1,78 +0,0 @@
-/**
- * Database operation extraction from entity coordinates.
- *
- * Parses Supabase/Prisma call targets in the edge set and db statements in
- * the semantics dimension to answer: which tables does this entity read or
- * write? This is the δ-contract surface that conflict_matrix uses to detect
- * tasks that collide through shared data even when their symbols and files
- * are disjoint (the "spawner oscillation" class of conflict).
- *
- * Ported from apps/api/routes/mcp.js extractDbOperations so the package's
- * own tools (conflict_matrix) can use it without the cloud layer.
- */
-const WRITE_OPS = new Set(['insert', 'update', 'delete', 'upsert', 'create']);
-export function extractDbOps(entity) {
-    const ops = [];
-    const seen = new Set();
-    const push = (table, operation, isWrite) => {
-        const key = `${table}:${operation}`;
-        if (seen.has(key))
-            return;
-        seen.add(key);
-        ops.push({ table, operation, type: isWrite ? 'db_mutate' : 'db_query' });
-    };
-    const edges = entity.edges;
-    const callees = (edges?.callees || edges?.calls || []);
-    for (const callee of callees) {
-        const target = typeof callee === 'string' ? callee : callee?.target || callee?.id || '';
-        const fromMatch = target.match(/\.from\s*\(\s*['"`](\w+)['"`]\s*\)/);
-        if (fromMatch) {
-            const opMatch = target.match(/\.(insert|update|delete|select|upsert|rpc)\s*\(/);
-            const operation = opMatch ? opMatch[1] : 'query';
-            push(fromMatch[1], operation, WRITE_OPS.has(operation));
-        }
-        const prismaMatch = target.match(/prisma\.(\w+)\.(findMany|findUnique|findFirst|create|update|delete|upsert|count|aggregate)\s*\(/);
-        if (prismaMatch) {
-            push(prismaMatch[1], prismaMatch[2], WRITE_OPS.has(prismaMatch[2]));
-        }
-    }
-    function scanSemantics(stmts) {
-        if (!Array.isArray(stmts))
-            return;
-        for (const stmt of stmts) {
-            if (!stmt || typeof stmt !== 'object')
-                continue;
-            if (stmt.type === 'db_query' || stmt.type === 'db_mutate') {
-                push(String(stmt.model || 'unknown'), String(stmt.operation || 'unknown'), stmt.type === 'db_mutate');
-            }
-            if (stmt.then)
-                scanSemantics(stmt.then);
-            if (stmt.else)
-                scanSemantics(stmt.else);
-            if (stmt.body)
-                scanSemantics(stmt.body);
-            if (stmt.catch?.body)
-                scanSemantics(stmt.catch.body);
-            if (stmt.finally)
-                scanSemantics(stmt.finally);
-        }
-    }
-    scanSemantics(entity.semantics);
-    return ops;
-}
-/** Aggregate db ops for a set of entities into read/write table sets. */
-export function tableContract(entities) {
-    const reads = new Set();
-    const writes = new Set();
-    for (const e of entities) {
-        for (const op of extractDbOps(e)) {
-            if (op.table === 'unknown')
-                continue;
-            if (op.type === 'db_mutate')
-                writes.add(op.table);
-            else
-                reads.add(op.table);
-        }
-    }
-    return { reads, writes };
-}

package/dist/tools/diff.d.ts

@@ -1,28 +0,0 @@
-/**
- * Cross-Bundle Analysis Tools: diff_bundle + conflict_matrix
- *
- * diff_bundle: Compare entities between a worktree and the loaded project.
- * conflict_matrix: Classify conflict tiers for parallel task scheduling.
- *
- * These tools compare TWO entity sets (base vs branch, or task vs task),
- * unlike the single-bundle queries in index.ts and functors.ts.
- */
-import type { ProjectLoader } from '../types.js';
-export declare function diffBundle(args: {
-    worktree_path: string;
-    project?: string;
-    include_unchanged?: boolean;
-}, loader: ProjectLoader): Promise<unknown>;
-export declare function conflictMatrix(args: {
-    tasks: Array<{
-        id: string;
-        entity_ids: string[];
-        dimensions?: string[];
-        expand_blast_radius?: boolean;
-    }>;
-    project?: string;
-}, loader: ProjectLoader, extras?: {
-    /** Lineage-backed co-change provider: given entity ids, returns a map of
-     *  sorted-pair keys (`${idA}
${idB}`) → shared commit counts. */
-    fetchCoChanges?: (entityIds: string[]) => Promise<Map<string, number>>;
-}): Promise<unknown>;