@diff-review-system/drs 4.0.0-rc.4 → 4.1.0

package/dist/pi/sdk.js

@@ -1,8 +1,15 @@
 import { randomUUID } from 'crypto';
+import { spawn } from 'child_process';
 import { isAbsolute, join, resolve } from 'path';
 import { Type } from '@sinclair/typebox';
-import { AuthStorage, createAgentSession, DefaultResourceLoader, getAgentDir, ModelRegistry, SettingsManager, SessionManager, } from '@mariozechner/pi-coding-agent';
+import { AuthStorage, createAgentSession, DefaultResourceLoader, getAgentDir, ModelRegistry, SettingsManager, SessionManager, } from '@earendil-works/pi-coding-agent';
 import { writeJsonOutput } from '../lib/write-json-output.js';
+import { writeArtifactOutput } from '../lib/html-artifact.js';
+import { isReviewArtifactPayload } from '../lib/review-artifact.js';
+import { resolveWithinWorkingDir } from '../lib/path-utils.js';
+const DEFAULT_GIT_DIFF_MAX_BYTES = 120_000;
+const HARD_GIT_DIFF_MAX_BYTES = 500_000;
+const GIT_DIFF_STDERR_MAX_BYTES = 16_384;
 function asRecord(value) {
     return value && typeof value === 'object' && !Array.isArray(value)
         ? value
@@ -148,6 +155,162 @@ function asPositiveInt(value) {
     const rounded = Math.round(value);
     return rounded > 0 ? rounded : undefined;
 }
+function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return 'Unknown error';
+    }
+}
+function normalizeGitDiffPath(file) {
+    const trimmed = file.trim();
+    if (!trimmed) {
+        throw new Error('git_diff requires a non-empty file path');
+    }
+    if (trimmed.includes('\0')) {
+        throw new Error('git_diff file path must not contain NUL bytes');
+    }
+    if (isAbsolute(trimmed)) {
+        throw new Error('git_diff only accepts repository-relative file paths');
+    }
+    if (trimmed.split(/[\\/]+/).includes('..')) {
+        throw new Error('git_diff file path must stay inside the repository');
+    }
+    const resolved = resolve('/', trimmed);
+    const relativePath = resolved.slice(1);
+    if (!relativePath || relativePath === '..' || relativePath.startsWith('../')) {
+        throw new Error('git_diff file path must stay inside the repository');
+    }
+    return relativePath;
+}
+function normalizeGitRev(value, label) {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    if (trimmed.startsWith('-') || trimmed.includes('\0') || /\s/.test(trimmed)) {
+        throw new Error(`git_diff ${label} revision is not allowed`);
+    }
+    return trimmed;
+}
+function normalizeGitDiffMaxBytes(maxBytes) {
+    if (!maxBytes || !Number.isFinite(maxBytes)) {
+        return DEFAULT_GIT_DIFF_MAX_BYTES;
+    }
+    return Math.max(1, Math.min(Math.floor(maxBytes), HARD_GIT_DIFF_MAX_BYTES));
+}
+function appendCappedChunk(chunks, chunk, maxBytes) {
+    const currentBytes = chunks.reduce((sum, existing) => sum + existing.length, 0);
+    const remaining = maxBytes - currentBytes;
+    if (remaining <= 0) {
+        return chunk.length > 0;
+    }
+    if (chunk.length <= remaining) {
+        chunks.push(chunk);
+        return false;
+    }
+    chunks.push(chunk.subarray(0, remaining));
+    return true;
+}
+function runGitDiff(workingDir, args, maxBytes) {
+    return new Promise((resolvePromise, reject) => {
+        const child = spawn('git', ['diff', '--no-ext-diff', '-M', ...args], {
+            cwd: workingDir,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        let truncated = false;
+        child.stdout.on('data', (chunk) => {
+            truncated = appendCappedChunk(stdoutChunks, chunk, maxBytes) || truncated;
+        });
+        child.stderr.on('data', (chunk) => {
+            appendCappedChunk(stderrChunks, chunk, GIT_DIFF_STDERR_MAX_BYTES);
+        });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            const stderr = Buffer.concat(stderrChunks).toString('utf8').trim();
+            if (code !== 0) {
+                reject(new Error(stderr || `git diff exited with code ${code ?? 'unknown'}`));
+                return;
+            }
+            resolvePromise({
+                stdout: Buffer.concat(stdoutChunks).toString('utf8'),
+                truncated,
+            });
+        });
+    });
+}
+function runGitNameStatus(workingDir, args) {
+    return new Promise((resolvePromise, reject) => {
+        const child = spawn('git', ['diff', '--name-status', '-M', ...args], {
+            cwd: workingDir,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        child.stdout.on('data', (chunk) => {
+            stdoutChunks.push(chunk);
+        });
+        child.stderr.on('data', (chunk) => {
+            appendCappedChunk(stderrChunks, chunk, GIT_DIFF_STDERR_MAX_BYTES);
+        });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            const stderr = Buffer.concat(stderrChunks).toString('utf8').trim();
+            if (code !== 0) {
+                reject(new Error(stderr || `git diff --name-status exited with code ${code ?? 'unknown'}`));
+                return;
+            }
+            resolvePromise(Buffer.concat(stdoutChunks).toString('utf8'));
+        });
+    });
+}
+function extractGitDiffMetadata(diff) {
+    const lines = diff.split('\n');
+    const oldPath = lines
+        .find((line) => line.startsWith('rename from '))
+        ?.slice('rename from '.length);
+    const newPath = lines.find((line) => line.startsWith('rename to '))?.slice('rename to '.length);
+    return {
+        binary: lines.some((line) => line.startsWith('Binary files ') || line.startsWith('GIT binary patch')),
+        deleted: lines.some((line) => line.startsWith('deleted file mode')),
+        renamed: oldPath !== undefined || newPath !== undefined,
+        oldPath,
+        newPath,
+        empty: diff.trim().length === 0,
+    };
+}
+function mergeGitNameStatusMetadata(metadata, nameStatus, file) {
+    for (const line of nameStatus.split('\n')) {
+        const parts = line.split('\t');
+        const status = parts[0];
+        if (!status)
+            continue;
+        if (status.startsWith('R') && parts[2] === file) {
+            return {
+                ...metadata,
+                renamed: true,
+                oldPath: parts[1],
+                newPath: parts[2],
+            };
+        }
+        if (status === 'D' && parts[1] === file) {
+            return {
+                ...metadata,
+                deleted: true,
+            };
+        }
+    }
+    return metadata;
+}
 function normalizeAgentSkills(value) {
     const normalized = {};
     for (const [agentName, skills] of Object.entries(value)) {
@@ -158,6 +321,188 @@ function normalizeAgentSkills(value) {
     }
     return normalized;
 }
+function parseFixChecks(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const checks = [];
+    for (const entry of value) {
+        const record = asRecord(entry);
+        const name = asString(record.name);
+        const command = asString(record.command);
+        if (!name || !command) {
+            continue;
+        }
+        const check = { name, command };
+        const matchPaths = asStringArray(record.matchPaths);
+        if (matchPaths && matchPaths.length > 0) {
+            check.matchPaths = matchPaths;
+        }
+        const timeoutMs = asNumber(record.timeoutMs);
+        if (timeoutMs !== undefined) {
+            check.timeoutMs = timeoutMs;
+        }
+        checks.push(check);
+    }
+    return checks.length > 0 ? checks : undefined;
+}
+const DEFAULT_CHECK_TIMEOUT_MS = 120_000;
+const HARD_CHECK_TIMEOUT_MS = 600_000;
+const CHECK_OUTPUT_MAX_BYTES = 64_000;
+function normalizeCheckTimeout(timeoutMs) {
+    if (!timeoutMs || !Number.isFinite(timeoutMs)) {
+        return DEFAULT_CHECK_TIMEOUT_MS;
+    }
+    return Math.max(1_000, Math.min(Math.floor(timeoutMs), HARD_CHECK_TIMEOUT_MS));
+}
+function globToRegex(pattern) {
+    let regex = '';
+    let i = 0;
+    while (i < pattern.length) {
+        const char = pattern[i];
+        if (char === '*' && pattern[i + 1] === '*') {
+            regex += '.*';
+            i += 2;
+            if (pattern[i] === '/') {
+                i++;
+            }
+        }
+        else if (char === '*') {
+            regex += '[^/]*';
+            i++;
+        }
+        else if (char === '?') {
+            regex += '[^/]';
+            i++;
+        }
+        else if ('.+^${}()|[]\\'.includes(char)) {
+            regex += '\\' + char;
+            i++;
+        }
+        else {
+            regex += char;
+            i++;
+        }
+    }
+    return new RegExp('^' + regex + '$');
+}
+function fileMatchesGlobs(filePath, patterns) {
+    if (!patterns || patterns.length === 0) {
+        return true;
+    }
+    return patterns.some((pattern) => globToRegex(pattern).test(filePath));
+}
+async function getChangedFiles(workingDir) {
+    return new Promise((resolvePromise) => {
+        const child = spawn('git', ['status', '--porcelain', '--no-renames'], {
+            cwd: workingDir,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const stdoutChunks = [];
+        child.stdout.on('data', (chunk) => stdoutChunks.push(chunk));
+        child.on('error', () => resolvePromise([]));
+        child.on('close', () => {
+            const output = Buffer.concat(stdoutChunks).toString('utf8').trim();
+            resolvePromise(output
+                ? output
+                    .split('\n')
+                    .map((line) => line.slice(3).trim())
+                    .filter(Boolean)
+                : []);
+        });
+    });
+}
+function runCheckCommand(workingDir, check) {
+    return new Promise((resolvePromise) => {
+        const timeoutMs = normalizeCheckTimeout(check.timeoutMs);
+        const child = spawn(check.command, {
+            cwd: workingDir,
+            shell: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        let truncated = false;
+        let timedOut = false;
+        const startTime = Date.now();
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGTERM');
+        }, timeoutMs);
+        child.stdout.on('data', (chunk) => {
+            truncated = appendCappedChunk(stdoutChunks, chunk, CHECK_OUTPUT_MAX_BYTES) || truncated;
+        });
+        child.stderr.on('data', (chunk) => {
+            appendCappedChunk(stderrChunks, chunk, CHECK_OUTPUT_MAX_BYTES);
+        });
+        child.on('error', () => {
+            clearTimeout(timer);
+            resolvePromise({
+                name: check.name,
+                command: check.command,
+                exitCode: null,
+                stdout: '',
+                stderr: `Failed to spawn: ${check.command}`,
+                truncated: false,
+                skipped: false,
+                durationMs: Date.now() - startTime,
+            });
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            resolvePromise({
+                name: check.name,
+                command: check.command,
+                exitCode: timedOut ? null : code,
+                stdout: Buffer.concat(stdoutChunks).toString('utf8'),
+                stderr: (timedOut ? `Timed out after ${timeoutMs}ms\n` : '') +
+                    Buffer.concat(stderrChunks).toString('utf8'),
+                truncated,
+                skipped: false,
+                durationMs: Date.now() - startTime,
+            });
+        });
+    });
+}
+function findingIdParamProvided(params) {
+    return typeof params.findingId === 'string' && params.findingId.trim().length > 0;
+}
+function extractFindingFromArtifact(raw, findingId) {
+    const envelope = raw;
+    const payload = envelope?.payload ?? raw;
+    if (!isReviewArtifactPayload(payload)) {
+        return undefined;
+    }
+    return payload.findings.find((f) => f.id === findingId);
+}
+function buildArtifactManifest(raw, artifactPath) {
+    const envelope = raw;
+    const payload = envelope?.payload ?? raw;
+    if (!isReviewArtifactPayload(payload)) {
+        return { artifactPath, ok: false, totalFindings: 0, actionableFindings: 0, findings: [] };
+    }
+    const findings = payload.findings.map((f) => ({
+        id: f.id,
+        severity: f.issue.severity,
+        state: f.state,
+        disposition: f.disposition,
+        file: f.issue.file,
+        line: f.issue.line,
+        title: f.issue.title,
+    }));
+    const actionableFindings = findings.filter((f) => f.state === 'open' &&
+        (f.disposition === 'still_open' ||
+            f.disposition === 'partial' ||
+            f.disposition === 'regression')).length;
+    return {
+        artifactPath,
+        ok: true,
+        reviewId: payload.reviewId,
+        totalFindings: findings.length,
+        actionableFindings,
+        findings,
+    };
+}
 function normalizeSkillPath(cwd, skillPath) {
     return isAbsolute(skillPath) ? resolve(skillPath) : resolve(cwd, skillPath);
 }
@@ -255,6 +600,8 @@ class PiSessionRuntime {
             skillSearchPaths: asStringArray(config.skillSearchPaths),
             agentSkills: normalizeAgentSkills(asRecord(config.agentSkills)),
             thinkingLevel: asString(config.thinkingLevel),
+            fixChecks: parseFixChecks(config.fixChecks),
+            traceCollector: config.traceCollector,
             retry: asRecord(config.retry),
         };
         this.authStorage = AuthStorage.create();
@@ -409,22 +756,26 @@ class PiSessionRuntime {
     resolveSkillSearchPaths(cwd) {
         const configuredPaths = this.runtimeConfig.skillSearchPaths ?? [];
         if (configuredPaths.length === 0) {
-            return [join(cwd, '.drs', 'skills'), join(cwd, '.pi', 'skills')];
+            return [
+                join(cwd, '.agents', 'skills'),
+                join(cwd, '.drs', 'skills'),
+                join(cwd, '.pi', 'skills'),
+            ];
         }
         return configuredPaths.map((skillPath) => normalizeSkillPath(cwd, skillPath));
     }
     resolveAgentSkills(agentName) {
         return this.runtimeConfig.agentSkills?.[agentName] ?? [];
     }
-    resolveCustomTools(workingDir) {
+    resolveCustomTools(workingDir, agentTools) {
         const customTools = [];
-        if (this.isToolEnabled('write_json_output', true)) {
+        if (this.isToolEnabled('write_json_output', true, agentTools)) {
             customTools.push({
                 name: 'write_json_output',
                 label: 'write_json_output',
                 description: 'Validate and write structured JSON output for DRS agents.',
                 parameters: Type.Object({
-                    outputType: Type.Union([Type.Literal('describe_output'), Type.Literal('review_output')]),
+                    outputType: Type.Literal('describe_output'),
                     payload: Type.Any(),
                     pretty: Type.Optional(Type.Boolean()),
                     indent: Type.Optional(Type.Number({ minimum: 2, maximum: 8 })),
@@ -444,6 +795,210 @@ class PiSessionRuntime {
                 },
             });
         }
+        if (this.isToolEnabled('write_artifact_output', false, agentTools)) {
+            customTools.push({
+                name: 'write_artifact_output',
+                label: 'write_artifact_output',
+                description: 'Validate and write a self-contained HTML artifact for DRS agents.',
+                parameters: Type.Object({
+                    outputPath: Type.String({ minLength: 1 }),
+                    content: Type.String({ minLength: 1 }),
+                }),
+                execute: async (_toolCallId, params) => {
+                    const pointer = await writeArtifactOutput({
+                        outputPath: params.outputPath,
+                        content: params.content,
+                        workingDir,
+                    });
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(pointer) }],
+                        details: pointer,
+                    };
+                },
+            });
+        }
+        if (this.isToolEnabled('git_diff', false, agentTools)) {
+            customTools.push({
+                name: 'git_diff',
+                label: 'git_diff',
+                description: 'Read a unified git diff for one repository-relative file path.',
+                parameters: Type.Object({
+                    file: Type.String({ minLength: 1 }),
+                    base: Type.Optional(Type.String()),
+                    head: Type.Optional(Type.String()),
+                    maxBytes: Type.Optional(Type.Number({ minimum: 1, maximum: HARD_GIT_DIFF_MAX_BYTES })),
+                }),
+                execute: async (_toolCallId, params) => {
+                    const file = normalizeGitDiffPath(params.file);
+                    const base = normalizeGitRev(params.base, 'base');
+                    const head = normalizeGitRev(params.head, 'head');
+                    const maxBytes = normalizeGitDiffMaxBytes(params.maxBytes);
+                    const range = base && head ? [`${base}...${head}`] : base ? [base] : [];
+                    let diff = '';
+                    let truncated = false;
+                    let error;
+                    try {
+                        const result = await runGitDiff(workingDir, [...range, '--', file], maxBytes);
+                        diff = result.stdout;
+                        truncated = result.truncated;
+                    }
+                    catch (caught) {
+                        error = caught instanceof Error ? caught.message : String(caught);
+                    }
+                    let metadata = extractGitDiffMetadata(diff);
+                    if (error === undefined && range.length > 0) {
+                        try {
+                            const nameStatus = await runGitNameStatus(workingDir, range);
+                            metadata = mergeGitNameStatusMetadata(metadata, nameStatus, file);
+                        }
+                        catch {
+                            // Diff text remains authoritative; name-status only enriches metadata.
+                        }
+                    }
+                    const details = {
+                        file,
+                        base,
+                        head,
+                        ok: error === undefined,
+                        error,
+                        truncated,
+                        bytes: Buffer.byteLength(diff, 'utf8'),
+                        metadata,
+                        diff,
+                    };
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(details) }],
+                        details,
+                    };
+                },
+            });
+        }
+        if (this.isToolEnabled('read_artifact', false, agentTools)) {
+            customTools.push({
+                name: 'read_artifact',
+                label: 'read_artifact',
+                description: 'Read a DRS review artifact from a file path. ' +
+                    'Without findingId: returns a compact manifest of all findings (id, severity, state, disposition, file, line, title). ' +
+                    'With findingId: returns the full finding detail including issue, verification rationale, and fingerprint.',
+                parameters: Type.Object({
+                    artifactPath: Type.String({ minLength: 1 }),
+                    findingId: Type.Optional(Type.String({ minLength: 1 })),
+                }),
+                execute: async (_toolCallId, params) => {
+                    const { readFile } = await import('fs/promises');
+                    try {
+                        const fullPath = resolveWithinWorkingDir(workingDir, params.artifactPath, 'read');
+                        const raw = JSON.parse(await readFile(fullPath, 'utf-8'));
+                        if (findingIdParamProvided(params)) {
+                            const finding = extractFindingFromArtifact(raw, params.findingId);
+                            if (!finding) {
+                                const details = {
+                                    artifactPath: params.artifactPath,
+                                    findingId: params.findingId,
+                                    ok: false,
+                                    error: `Finding "${params.findingId}" not found in artifact`,
+                                };
+                                return {
+                                    content: [{ type: 'text', text: JSON.stringify(details) }],
+                                    details,
+                                };
+                            }
+                            const details = {
+                                artifactPath: params.artifactPath,
+                                findingId: params.findingId,
+                                ok: true,
+                                finding,
+                            };
+                            return {
+                                content: [{ type: 'text', text: JSON.stringify(details) }],
+                                details,
+                            };
+                        }
+                        const manifest = buildArtifactManifest(raw, params.artifactPath);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(manifest) }],
+                            details: manifest,
+                        };
+                    }
+                    catch (caught) {
+                        const error = formatUnknownError(caught);
+                        const details = {
+                            artifactPath: params.artifactPath,
+                            findingId: params.findingId,
+                            ok: false,
+                            error,
+                        };
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(details) }],
+                            details,
+                        };
+                    }
+                },
+            });
+        }
+        if (this.isToolEnabled('drs_check', false, agentTools) && this.runtimeConfig.fixChecks) {
+            const configuredChecks = this.runtimeConfig.fixChecks;
+            customTools.push({
+                name: 'drs_check',
+                label: 'drs_check',
+                description: 'Run configured DRS fix checks (type-check, lint, tests, etc.). ' +
+                    'Without name: runs all applicable checks (filtered by matchPaths against changed files). ' +
+                    'With name: runs a single named check. ' +
+                    'Returns exit code, stdout, and stderr for each check.',
+                parameters: Type.Object({
+                    name: Type.Optional(Type.String({ minLength: 1 })),
+                }),
+                execute: async (_toolCallId, params) => {
+                    const changedFiles = await getChangedFiles(workingDir);
+                    let checksToRun;
+                    if (params.name) {
+                        const match = configuredChecks.find((c) => c.name === params.name);
+                        if (!match) {
+                            const details = {
+                                ok: false,
+                                error: `No check named "${params.name}" is configured`,
+                                availableChecks: configuredChecks.map((c) => c.name),
+                            };
+                            return {
+                                content: [{ type: 'text', text: JSON.stringify(details) }],
+                                details,
+                            };
+                        }
+                        checksToRun = [match];
+                    }
+                    else {
+                        checksToRun = configuredChecks.filter((check) => !check.matchPaths ||
+                            check.matchPaths.length === 0 ||
+                            changedFiles.some((f) => fileMatchesGlobs(f, check.matchPaths)));
+                    }
+                    if (checksToRun.length === 0) {
+                        const details = {
+                            ok: true,
+                            checks: [],
+                            changedFiles,
+                            skipped: 'No applicable checks for changed files',
+                        };
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(details) }],
+                            details,
+                        };
+                    }
+                    const results = [];
+                    for (const check of checksToRun) {
+                        results.push(await runCheckCommand(workingDir, check));
+                    }
+                    const details = {
+                        ok: results.every((r) => r.exitCode === 0),
+                        checks: results,
+                        changedFiles,
+                    };
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(details) }],
+                        details,
+                    };
+                },
+            });
+        }
         return customTools;
     }
     async createAgentSession(cwd, agentName) {
@@ -487,6 +1042,11 @@ class PiSessionRuntime {
                 },
             })
             : undefined;
+        const customTools = this.resolveCustomTools(cwd, settings.tools);
+        const tools = [
+            ...this.resolveTools(cwd, settings.tools),
+            ...customTools.map((tool) => tool.name),
+        ];
         const { session } = await createAgentSession({
             cwd,
             authStorage: this.authStorage,
@@ -495,8 +1055,8 @@ class PiSessionRuntime {
             resourceLoader,
             sessionManager: SessionManager.inMemory(),
             settingsManager,
-            tools: this.resolveTools(cwd, settings.tools),
-            customTools: this.resolveCustomTools(cwd),
+            tools,
+            customTools,
             thinkingLevel: this.runtimeConfig.thinkingLevel,
         });
         return session;
@@ -534,6 +1094,9 @@ class PiSessionRuntime {
                 record.session = await this.createAgentSession(cwd, input.body.agent);
                 record.agent = input.body.agent;
                 record.cwd = cwd;
+                if (this.runtimeConfig.traceCollector) {
+                    this.runtimeConfig.traceCollector.attachSession(record.session, record.id);
+                }
             }
             record.error = undefined;
             await record.session.prompt(promptText);
@@ -543,6 +1106,11 @@ class PiSessionRuntime {
             record.error = error;
             return { ok: false };
         }
+        finally {
+            if (this.runtimeConfig.traceCollector && record.session) {
+                this.runtimeConfig.traceCollector.finalizeSession(record.id);
+            }
+        }
     }
     readMessages(input) {
         const record = this.getSessionRecord(input.path.id);
@@ -563,7 +1131,7 @@ class PiSessionRuntime {
                     id: `${record.id}-error`,
                     role: 'assistant',
                     time: { completed: Date.now() },
-                    error: record.error instanceof Error ? record.error.message : String(record.error),
+                    error: formatUnknownError(record.error),
                 },
                 parts: [{ text: '' }],
             });