vibe-splain 3.4.2 → 3.5.0

package/dist/mcp/tools/work_orders.js

@@ -1,126 +0,0 @@
-import { PointerStore } from '../../store/PointerStore.js';
-import { v4 as uuidv4 } from 'uuid';
-export const createWorkOrderTool = {
-    name: 'create_work_order',
-    description: 'Creates a new Work Order defining intent, allowed file scope, and required verifiable proof. Returns the workOrderId and a manifestPointer for use with spawn_worker.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            projectRoot: { type: 'string', description: 'Absolute project root' },
-            intent: { type: 'string', description: 'Plain-language description of what the worker should do' },
-            allowedFiles: {
-                type: 'array',
-                items: { type: 'string' },
-                description: 'Explicit file paths (relative to projectRoot) the worker may read/write',
-            },
-            allowedGlobs: {
-                type: 'array',
-                items: { type: 'string' },
-                description: 'Glob patterns for allowed files',
-            },
-            deniedGlobs: {
-                type: 'array',
-                items: { type: 'string' },
-                description: 'Glob patterns that override allowedFiles/allowedGlobs',
-            },
-            requiredProof: {
-                type: 'array',
-                items: {
-                    type: 'object',
-                    properties: {
-                        proofId: { type: 'string' },
-                        schemaName: { type: 'string', description: 'e.g. test_report.v1, patch_hash' },
-                        description: { type: 'string' },
-                    },
-                    required: ['proofId', 'schemaName', 'description'],
-                },
-                description: 'Machine-verifiable evidence the worker must provide',
-            },
-        },
-        required: ['projectRoot', 'intent', 'allowedFiles'],
-    },
-};
-export async function handleCreateWorkOrder(args) {
-    const projectRoot = args.projectRoot;
-    const intent = args.intent;
-    const allowedFiles = args.allowedFiles ?? [];
-    const allowedGlobs = args.allowedGlobs ?? [];
-    const deniedGlobs = args.deniedGlobs ?? [];
-    const requiredProof = args.requiredProof ?? [];
-    if (!projectRoot || !intent) {
-        throw new Error('projectRoot and intent are required');
-    }
-    const workOrderId = `wo_${uuidv4().replace(/-/g, '').slice(0, 16)}`;
-    const pointerStore = PointerStore.open(projectRoot);
-    await pointerStore.insertWorkOrder({
-        workOrderId,
-        intent,
-        allowedFiles: JSON.stringify(allowedFiles),
-        allowedGlobs: JSON.stringify(allowedGlobs),
-        deniedGlobs: JSON.stringify(deniedGlobs),
-        requiredProof: JSON.stringify(requiredProof),
-        status: 'pending',
-        createdAt: Date.now(),
-    });
-    return {
-        ok: true,
-        workOrderId,
-        intent,
-        allowedFiles,
-        allowedGlobs,
-        deniedGlobs,
-        requiredProof,
-        nextStep: `Call spawn_worker with workOrderId "${workOrderId}" to generate a DelegationRequest`,
-    };
-}
-export const spawnWorkerTool = {
-    name: 'spawn_worker',
-    description: 'Generates a DelegationRequest from a Work Order. The Client Orchestrator uses this object to spawn an isolated Worker session. The MCP server does NOT spawn any subprocess.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            projectRoot: { type: 'string', description: 'Absolute project root' },
-            workOrderId: { type: 'string', description: 'ID returned by create_work_order' },
-        },
-        required: ['projectRoot', 'workOrderId'],
-    },
-};
-export async function handleSpawnWorker(args) {
-    const projectRoot = args.projectRoot;
-    const workOrderId = args.workOrderId;
-    if (!projectRoot || !workOrderId) {
-        throw new Error('projectRoot and workOrderId are required');
-    }
-    const pointerStore = PointerStore.open(projectRoot);
-    const row = pointerStore.getWorkOrder(workOrderId);
-    if (!row) {
-        throw new Error(`WorkOrderNotFound: ${workOrderId}`);
-    }
-    if (row.status === 'completed' || row.status === 'failed' || row.status === 'active') {
-        throw new Error(`WorkOrderClosed: ${workOrderId} is already ${row.status}`);
-    }
-    await pointerStore.updateWorkOrderStatus(workOrderId, 'active');
-    const delegationRequest = {
-        schemaVersion: '1.0.0',
-        workOrderId: row.workOrderId,
-        intent: row.intent,
-        sessionScope: {
-            allowedFiles: JSON.parse(row.allowedFiles),
-            allowedGlobs: JSON.parse(row.allowedGlobs),
-            deniedGlobs: JSON.parse(row.deniedGlobs),
-        },
-        requiredProof: JSON.parse(row.requiredProof),
-        instructions: [
-            `1. Call set_session_scope with workOrderId "${workOrderId}" before any file operations.`,
-            '2. Only read/write files within the sessionScope.',
-            '3. If you need a file outside scope, call yield_for_scope_expansion — do NOT proceed.',
-            '4. On completion, call submit_receipt with proof for every requiredProof entry.',
-        ],
-    };
-    return {
-        ok: true,
-        delegationRequest,
-        note: 'The Client Orchestrator must spawn the Worker session using this DelegationRequest. The MCP server does not spawn subprocesses.',
-    };
-}
-//# sourceMappingURL=work_orders.js.map

package/dist/mcp/tools/yield_for_scope_expansion.d.ts

@@ -1,29 +0,0 @@
-export declare const yieldForScopeExpansionTool: {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            requestedPaths: {
-                type: string;
-                items: {
-                    type: string;
-                };
-                description: string;
-            };
-            reason: {
-                type: string;
-                description: string;
-            };
-            evidencePointers: {
-                type: string;
-                items: {
-                    type: string;
-                };
-                description: string;
-            };
-        };
-        required: string[];
-    };
-};
-export declare function handleYieldForScopeExpansion(args: Record<string, unknown>): Promise<unknown>;

package/dist/mcp/tools/yield_for_scope_expansion.js

@@ -1,59 +0,0 @@
-import { SessionScope } from '../SessionScope.js';
-export const yieldForScopeExpansionTool = {
-    name: 'yield_for_scope_expansion',
-    description: 'Worker signals that it needs to access files outside its current scope. Immediately terminates the active scope and returns a Blocked receipt. The Manager must evaluate the evidence and decide whether to spawn a new Worker with expanded scope.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            requestedPaths: {
-                type: 'array',
-                items: { type: 'string' },
-                description: 'Paths the worker needs but cannot access under current scope',
-            },
-            reason: {
-                type: 'string',
-                description: 'Why these paths are needed — root cause found in out-of-scope file',
-            },
-            evidencePointers: {
-                type: 'array',
-                items: { type: 'string' },
-                description: 'Pointer IDs for artifacts that justify the expansion request',
-            },
-        },
-        required: ['requestedPaths', 'reason'],
-    },
-};
-export async function handleYieldForScopeExpansion(args) {
-    const requestedPaths = args.requestedPaths ?? [];
-    const reason = args.reason;
-    const evidencePointers = args.evidencePointers ?? [];
-    if (!requestedPaths.length || !reason) {
-        throw new Error('requestedPaths and reason are required');
-    }
-    const currentScope = SessionScope.get();
-    const workOrderId = currentScope?.workOrderId ?? 'unknown';
-    // Immediately clear the active scope — Worker is now blocked
-    SessionScope.clear();
-    // Return strict Blocked status per ADR-033
-    return {
-        status: 'blocked',
-        workOrderId,
-        requestedPaths,
-        reason,
-        evidencePointers,
-        receipt: {
-            workOrderId,
-            status: 'blocked',
-            proofPointers: [],
-            changedFiles: [],
-            summary: `Worker blocked: scope expansion required. Reason: ${reason}`,
-        },
-        managerInstructions: [
-            'Worker has been terminated. Active session scope has been cleared.',
-            'Evaluate the evidence pointers and reason.',
-            'If expansion is warranted, create a new Work Order with the expanded allowedFiles and spawn a new Worker.',
-            'If expansion is NOT warranted, the task is failed — do not retry with same scope.',
-        ],
-    };
-}
-//# sourceMappingURL=yield_for_scope_expansion.js.map