presubmit 0.1.0

package/dist/packages/agent-pi/src/history.js

@@ -0,0 +1,34 @@
+import { mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { SessionManager } from '@earendil-works/pi-coding-agent';
+/** Code, reviews, and clarification replies share this application's session history. */
+export async function conversationHistory(options) {
+    const directory = join(options.dataDir, 'pi-sessions');
+    await mkdir(directory, { recursive: true });
+    return SessionManager.continueRecent(options.cwd, directory);
+}
+export function recordClarification(history, options, question, model) {
+    history.appendMessage({
+        role: 'user',
+        content: [{ type: 'text', text: options.prompt }, ...(options.images ?? [])],
+        timestamp: Date.now(),
+    });
+    // Persist the reply shown to the user, excluding the classifier's internal tool call.
+    history.appendMessage({
+        role: 'assistant',
+        content: [{ type: 'text', text: question }],
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        usage: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            totalTokens: 0,
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+        },
+        stopReason: 'stop',
+        timestamp: Date.now(),
+    });
+}

package/dist/packages/agent-pi/src/index.js

@@ -0,0 +1,177 @@
+import { fork } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { isPiEvent, isStartOptions } from './ipc.js';
+export async function getConfiguration(runtimeOptions) {
+    try {
+        const { selectModel } = await import('./model.js');
+        const { model } = await selectModel(runtimeOptions);
+        return { configured: true, model: `${model.provider}/${model.id}` };
+    }
+    catch (error) {
+        return { configured: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+/** Each run has a dedicated SDK process; the application remains authoritative. */
+export class PiAgent {
+    onEvent;
+    child;
+    timers = new Map();
+    exited = Promise.resolve();
+    disposed = false;
+    constructor(onEvent) {
+        this.onEvent = onEvent;
+    }
+    start(options) {
+        if (this.disposed)
+            throw new Error('The agent has been disposed');
+        if (this.child)
+            throw new Error('An agent operation is already running');
+        if (!isStartOptions(options))
+            throw new Error('Invalid agent start options');
+        const worker = new URL(import.meta.url.endsWith('.ts') ? './worker.ts' : './worker.js', import.meta.url);
+        const child = fork(fileURLToPath(worker), [], {
+            cwd: options.cwd,
+            detached: process.platform !== 'win32',
+            // Resolve from Presubmit, since the session worktree may have no node_modules.
+            execArgv: worker.pathname.endsWith('.ts') ? ['--import', import.meta.resolve('tsx')] : [],
+            stdio: ['ignore', 'ignore', 'pipe', 'ipc'],
+        });
+        this.child = child;
+        let resolveExit;
+        this.exited = new Promise((resolve) => {
+            resolveExit = resolve;
+        });
+        let terminal = false;
+        let workerExited = false;
+        let terminalEvent;
+        let stderr = '';
+        child.stderr?.on('data', (chunk) => {
+            stderr = (stderr + String(chunk)).slice(-4000);
+        });
+        child.on('message', (raw) => {
+            if (!raw ||
+                typeof raw !== 'object' ||
+                !('version' in raw) ||
+                raw.version !== 1 ||
+                !('event' in raw))
+                return;
+            const event = raw.event;
+            if (!isPiEvent(event) || event.runId !== options.runId || terminal)
+                return;
+            if (event.type === 'complete' || event.type === 'error') {
+                terminal = true;
+                terminalEvent = event;
+                this.scheduleTermination(child);
+                return;
+            }
+            this.onEvent(event);
+        });
+        child.on('error', (error) => {
+            if (workerExited)
+                return;
+            terminal = true;
+            terminalEvent ??= { type: 'error', runId: options.runId, message: error.message };
+            // IPC errors can arrive while the worker is still alive. Keep ownership until exit.
+            if (child.pid)
+                this.scheduleTermination(child);
+            else {
+                workerExited = true;
+                if (this.child === child)
+                    this.child = undefined;
+                this.clearTimers(child);
+                resolveExit();
+                this.onEvent(terminalEvent);
+            }
+        });
+        child.on('exit', (code, signal) => {
+            workerExited = true;
+            if (this.child === child)
+                this.child = undefined;
+            this.clearTimers(child);
+            // Our shell backend inherits this group; clean up commands left in the background.
+            if (process.platform !== 'win32')
+                this.signal(child, 'SIGKILL');
+            resolveExit();
+            // Only release the next queued run after worker exit and process-group cleanup.
+            if (terminalEvent)
+                this.onEvent(terminalEvent);
+            else if (!terminal)
+                this.onEvent({
+                    type: 'error',
+                    runId: options.runId,
+                    message: `Agent worker exited (${signal ?? code}). ${stderr}`,
+                });
+        });
+        this.send({ version: 1, type: 'start', options });
+    }
+    send(command) {
+        if (this.child?.connected)
+            this.child.send(command);
+    }
+    clearTimers(child) {
+        for (const timer of this.timers.get(child) ?? [])
+            clearTimeout(timer);
+        this.timers.delete(child);
+    }
+    signal(child, signal) {
+        try {
+            if (process.platform !== 'win32' && child.pid)
+                process.kill(-child.pid, signal);
+            else
+                child.kill(signal);
+        }
+        catch (error) {
+            if (error.code !== 'ESRCH')
+                throw error;
+        }
+    }
+    scheduleTermination(child) {
+        if (this.timers.has(child))
+            return;
+        const term = setTimeout(() => this.signal(child, 'SIGTERM'), 3000);
+        const kill = setTimeout(() => this.signal(child, 'SIGKILL'), 5000);
+        term.unref();
+        kill.unref();
+        this.timers.set(child, [term, kill]);
+    }
+    answer(approvalId, allowed, automatic, policy, grant) {
+        this.send({ version: 1, type: 'answer', approvalId, allowed, automatic, policy, grant });
+    }
+    provideCheck(requestId, result, error) {
+        this.send({ version: 1, type: 'check_result', requestId, result, error });
+    }
+    provideReview(requestId, snapshot, error) {
+        this.send({ version: 1, type: 'review_snapshot', requestId, snapshot, error });
+    }
+    provideUserAnswer(requestId, answer, error) {
+        this.send({ version: 1, type: 'user_answer', requestId, answer, error });
+    }
+    provideMemory(requestId, result, error) {
+        this.send({ version: 1, type: 'memory_result', requestId, result, error });
+    }
+    provideHistory(requestId, hits, error) {
+        this.send({ version: 1, type: 'history_result', requestId, hits, error });
+    }
+    provideExecution(requestId, error) {
+        this.send({ version: 1, type: 'execution_result', requestId, error });
+    }
+    provideCoordinator(requestId, result, error) {
+        this.send({ version: 1, type: 'coordinator_result', requestId, result, error });
+    }
+    provideJevConsult(requestId, result, error) {
+        this.send({ version: 1, type: 'jev_consult_result', requestId, result, error });
+    }
+    providePlanning(requestId, board, error) {
+        this.send({ version: 1, type: 'planning_result', requestId, board, error });
+    }
+    cancel() {
+        this.send({ version: 1, type: 'cancel' });
+        if (this.child)
+            this.scheduleTermination(this.child);
+    }
+    dispose() {
+        this.disposed = true;
+        this.cancel();
+        return this.exited;
+    }
+}

package/dist/packages/agent-pi/src/ipc.js

@@ -0,0 +1,314 @@
+import { parseCheckRequest } from '../../protocol/src/checks.js';
+import { validateProjectAgentStart } from './agent-capabilities.js';
+import { agentId } from '../../protocol/src/agents.js';
+import { parseMemoryRequest } from '../../protocol/src/memory.js';
+import { isRecordedFileChange } from '../../protocol/src/session-changes.js';
+import { parseCoordinatorRequest } from '../../protocol/src/coordinator.js';
+import { parseTaskResult } from '../../protocol/src/delegation.js';
+import { parseUserQuestionRequest } from '../../protocol/src/user-questions.js';
+import { parsePlanningBoard } from '../../protocol/src/planning.js';
+import { reasoningLevels } from '../../protocol/src/index.js';
+import { parseTaskRoute } from './routing.js';
+import { parseJevConsultRequest } from '../../protocol/src/session-router.js';
+const object = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const string = (value) => typeof value === 'string';
+export function isShellApprovalAnswer(value) {
+    return (object(value) &&
+        value.version === 1 &&
+        value.type === 'answer' &&
+        string(value.approvalId) &&
+        typeof value.allowed === 'boolean' &&
+        (value.grant === undefined ||
+            (object(value.grant) &&
+                ['requestId', 'runId', 'command', 'cwd', 'policyRevision'].every((key) => string(value.grant[key])) &&
+                Number.isSafeInteger(value.grant.permissionVersion) &&
+                ['human', 'model', 'allowlist'].includes(String(value.grant.path)))) &&
+        (value.automatic === undefined || typeof value.automatic === 'boolean') &&
+        (value.policy === undefined ||
+            ((value.policy === 'model' || value.policy === 'allowlist') &&
+                value.allowed === true &&
+                value.automatic === true)));
+}
+export function isStartOptions(value) {
+    if (!object(value) ||
+        !['runId', 'cwd', 'dataDir', 'prompt'].every((key) => string(value[key])) ||
+        !['code', 'review', 'plan', 'research'].includes(String(value.mode)))
+        return false;
+    if (value.watchedChecks !== undefined && typeof value.watchedChecks !== 'boolean')
+        return false;
+    if (value.watchedChecks && (value.mode !== 'code' || value.snapshotOnly || value.projectAgent))
+        return false;
+    if (value.agentBuilderProjectId !== undefined) {
+        try {
+            agentId(value.agentBuilderProjectId);
+        }
+        catch {
+            return false;
+        }
+        if (value.mode !== 'code' || value.snapshotOnly || value.projectAgent || value.delegated)
+            return false;
+    }
+    if (value.projectAgent !== undefined) {
+        try {
+            validateProjectAgentStart(value);
+        }
+        catch {
+            return false;
+        }
+    }
+    if (value.snapshotOnly !== undefined && typeof value.snapshotOnly !== 'boolean')
+        return false;
+    if (value.snapshotOnly &&
+        (value.mode !== 'review' ||
+            !isReviewSnapshot(value.snapshot) ||
+            value.classify ||
+            value.route !== undefined ||
+            value.delegated ||
+            value.planning !== undefined ||
+            value.planningSourceRunIds !== undefined ||
+            value.delegationSummary !== undefined ||
+            value.coordinatorMessaging ||
+            value.historyRetrieval ||
+            value.projectMemory ||
+            value.images !== undefined))
+        return false;
+    if (value.images !== undefined &&
+        (!Array.isArray(value.images) ||
+            value.images.length > 10 ||
+            value.images.some((image) => !object(image) ||
+                image.type !== 'image' ||
+                !string(image.data) ||
+                !string(image.mimeType))))
+        return false;
+    if (value.delegated !== undefined && typeof value.delegated !== 'boolean')
+        return false;
+    if (value.coordinatorMessaging !== undefined && typeof value.coordinatorMessaging !== 'boolean')
+        return false;
+    if (value.jevConsult !== undefined && typeof value.jevConsult !== 'boolean')
+        return false;
+    if (value.jevConsult &&
+        (value.delegated || value.projectAgent || !['code', 'plan'].includes(String(value.mode))))
+        return false;
+    if (value.coordinatorMessaging &&
+        (value.delegated || !value.planning || !['code', 'plan'].includes(String(value.mode))))
+        return false;
+    if (value.projectMemory !== undefined && typeof value.projectMemory !== 'boolean')
+        return false;
+    if (value.projectMemory && (value.mode !== 'code' || value.snapshotOnly))
+        return false;
+    if (value.historyRetrieval !== undefined && typeof value.historyRetrieval !== 'boolean')
+        return false;
+    if (value.historyRetrieval && (value.mode !== 'code' || value.delegated))
+        return false;
+    if (value.delegated &&
+        (value.classify ||
+            value.route !== undefined ||
+            !['code', 'research'].includes(String(value.mode))))
+        return false;
+    if (value.mode === 'research' &&
+        ((!value.delegated && !value.projectAgent) || value.snapshot !== undefined))
+        return false;
+    if (value.delegationSummary !== undefined &&
+        (value.delegated || !string(value.delegationSummary) || value.delegationSummary.length > 30000))
+        return false;
+    if (value.planning !== undefined || value.mode === 'plan') {
+        try {
+            parsePlanningBoard(value.planning);
+        }
+        catch {
+            return false;
+        }
+        if (value.delegated ||
+            !Array.isArray(value.planningSourceRunIds) ||
+            !value.planningSourceRunIds.every(string) ||
+            !value.planningSourceRunIds.includes(String(value.runId)))
+            return false;
+    }
+    else if (value.planningSourceRunIds !== undefined || value.delegationSummary !== undefined)
+        return false;
+    if (value.mode === 'plan' &&
+        (value.classify || value.route !== undefined || value.snapshot !== undefined))
+        return false;
+    if (value.route !== undefined) {
+        try {
+            parseTaskRoute(value.route);
+        }
+        catch {
+            return false;
+        }
+    }
+    if (value.reasoningLevel !== undefined && !reasoningLevels.includes(value.reasoningLevel))
+        return false;
+    if (value.fastMode !== undefined && typeof value.fastMode !== 'boolean')
+        return false;
+    if (value.parallelFileReads !== undefined && typeof value.parallelFileReads !== 'boolean')
+        return false;
+    if (value.classify !== undefined && typeof value.classify !== 'boolean')
+        return false;
+    if (value.auth !== undefined &&
+        (!object(value.auth) ||
+            !string(value.auth.authPath) ||
+            (value.auth.provider !== undefined && !string(value.auth.provider)) ||
+            (value.auth.model !== undefined && !string(value.auth.model))))
+        return false;
+    if (value.snapshot === undefined)
+        return ['code', 'plan', 'research'].includes(String(value.mode));
+    return isReviewSnapshot(value.snapshot);
+}
+export function isReviewSnapshot(snapshot) {
+    return (object(snapshot) &&
+        string(snapshot.revision) &&
+        (snapshot.base === undefined || string(snapshot.base)) &&
+        (snapshot.target === undefined || string(snapshot.target)) &&
+        object(snapshot.files) &&
+        Object.values(snapshot.files).every(string) &&
+        (snapshot.diff === undefined || string(snapshot.diff)) &&
+        (snapshot.baseFiles === undefined ||
+            (object(snapshot.baseFiles) && Object.values(snapshot.baseFiles).every(string))));
+}
+export function isPiEvent(value) {
+    if (!object(value) || !string(value.runId))
+        return false;
+    switch (value.type) {
+        case 'check_request':
+            try {
+                if (!string(value.requestId) || !value.requestId.trim() || value.requestId.length > 128)
+                    return false;
+                parseCheckRequest(value.request);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        case 'file_change':
+            return isRecordedFileChange(value.change);
+        case 'execution_request':
+            return (string(value.requestId) &&
+                !!value.requestId.trim() &&
+                value.requestId.length <= 128 &&
+                (value.mode === 'code' || value.mode === 'plan'));
+        case 'user_question':
+            try {
+                if (!string(value.requestId) || !value.requestId.trim() || value.requestId.length > 128)
+                    return false;
+                parseUserQuestionRequest(value.question);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        case 'memory_request':
+            try {
+                if (!string(value.requestId) || !value.requestId.trim() || value.requestId.length > 128)
+                    return false;
+                parseMemoryRequest(value.request);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        case 'jev_consult_request':
+            try {
+                if (!string(value.requestId) || !value.requestId.trim() || value.requestId.length > 128)
+                    return false;
+                parseJevConsultRequest(value.request);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        case 'history_request':
+            return (string(value.requestId) &&
+                value.requestId.length <= 128 &&
+                string(value.query) &&
+                !!value.query.trim() &&
+                value.query.length <= 200 &&
+                Number.isInteger(value.limit) &&
+                Number(value.limit) >= 1 &&
+                Number(value.limit) <= 10);
+        case 'task_result':
+            try {
+                parseTaskResult(value.result);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        case 'task_question':
+            return string(value.question) && !!value.question.trim() && value.question.length <= 2000;
+        case 'coordinator_request':
+            try {
+                if (!string(value.requestId) || !value.requestId.trim() || value.requestId.length > 128)
+                    return false;
+                parseCoordinatorRequest(value.request);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        case 'planning_request':
+            if (!string(value.requestId))
+                return false;
+            if (value.board === undefined)
+                return true;
+            try {
+                parsePlanningBoard(value.board);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        case 'review_request':
+            return (string(value.requestId) &&
+                ['working', 'branch'].includes(String(value.scope)) &&
+                string(value.base) &&
+                value.base.trim().length > 0 &&
+                (value.target === undefined || (string(value.target) && value.target.trim().length > 0)));
+        case 'usage':
+            return (object(value.usage) &&
+                ['input', 'output', 'cacheRead', 'cacheWrite'].every((key) => Number.isSafeInteger(value.usage[key]) &&
+                    Number(value.usage[key]) >= 0) &&
+                (value.throughput === undefined ||
+                    (object(value.throughput) &&
+                        Number.isSafeInteger(value.throughput.outputTokens) &&
+                        Number(value.throughput.outputTokens) >= 0 &&
+                        Number.isSafeInteger(value.throughput.durationMs) &&
+                        Number(value.throughput.durationMs) > 0)));
+        case 'reasoning':
+        case 'text':
+            return string(value.text);
+        case 'tool_start':
+            return string(value.toolCallId) && string(value.name) && 'args' in value;
+        case 'tool_update':
+        case 'tool_end':
+            return (string(value.toolCallId) &&
+                string(value.name) &&
+                string(value.output) &&
+                (value.isError === undefined || typeof value.isError === 'boolean'));
+        case 'command_execution':
+            return (string(value.approvalId) &&
+                string(value.command) &&
+                string(value.cwd) &&
+                ['running', 'completed', 'failed'].includes(String(value.outcome)));
+        case 'approval':
+            return string(value.approvalId) && string(value.command);
+        case 'complete':
+            return (typeof value.cancelled === 'boolean' &&
+                (value.sessionFile === undefined || string(value.sessionFile)));
+        case 'error':
+            return string(value.message);
+        case 'finding': {
+            const f = value.finding;
+            return (object(f) &&
+                ['revision', 'file', 'title', 'explanation', 'evidence'].every((key) => string(f[key])) &&
+                ['left', 'right'].includes(String(f.side)) &&
+                ['P0', 'P1', 'P2', 'P3'].includes(String(f.severity)) &&
+                Number.isInteger(f.lineStart) &&
+                Number.isInteger(f.lineEnd) &&
+                Number(f.lineStart) > 0 &&
+                Number(f.lineEnd) >= Number(f.lineStart));
+        }
+        default:
+            return false;
+    }
+}