profclaw 2.0.0 → 2.4.0

package/dist/agents/receipt/receipt-writer.js

@@ -0,0 +1,186 @@
+/**
+ * Receipt writer: append-only JSONL, canonical JSON, SHA-256 hash chaining,
+ * secret redaction before hashing, optional Ed25519 signature on run_end.
+ * Spec: docs/specs/run-receipt-v0.md
+ */
+import { createHash, createPrivateKey, createPublicKey, sign as edSign } from 'node:crypto';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { GENESIS_HASH, RECEIPT_VERSION } from './receipt-types.js';
+// Canonical JSON
+/** Sorted keys, no whitespace, `undefined` members dropped, non-finite numbers rejected. */
+export function canonicalJson(value) {
+    if (value === null)
+        return 'null';
+    switch (typeof value) {
+        case 'string':
+        case 'boolean':
+            return JSON.stringify(value);
+        case 'number':
+            if (!Number.isFinite(value))
+                throw new Error('canonicalJson: non-finite number');
+            return JSON.stringify(value);
+        case 'object': {
+            if (Array.isArray(value)) {
+                return `[${value.map((v) => (v === undefined ? 'null' : canonicalJson(v))).join(',')}]`;
+            }
+            const obj = value;
+            const parts = [];
+            for (const key of Object.keys(obj).sort()) {
+                if (obj[key] === undefined)
+                    continue;
+                parts.push(`${JSON.stringify(key)}:${canonicalJson(obj[key])}`);
+            }
+            return `{${parts.join(',')}}`;
+        }
+        default:
+            throw new Error(`canonicalJson: unsupported type ${typeof value}`);
+    }
+}
+export function sha256Hex(input) {
+    return createHash('sha256').update(input).digest('hex');
+}
+/** Hash of an event: canonical JSON without `hash` and `signature`. */
+export function computeEventHash(event) {
+    const rest = { ...event };
+    delete rest['hash'];
+    delete rest['signature'];
+    return sha256Hex(canonicalJson(rest));
+}
+// Redaction
+export const REDACTED = '[REDACTED]';
+const SECRET_NAME = /(KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIAL)/i;
+const TOKEN_PATTERNS = [
+    /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+    /\bsk-[A-Za-z0-9_-]{16,}/g,
+    /\bgh[pousr]_[A-Za-z0-9]{20,}/g,
+    /\bgithub_pat_[A-Za-z0-9_]{20,}/g,
+    /\bxox[abprs]-[A-Za-z0-9-]{10,}/g,
+    /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g,
+    /\bAIza[0-9A-Za-z_-]{30,}/g,
+    /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g,
+    /\bnpm_[A-Za-z0-9]{30,}/g,
+];
+const BEARER = /\b(Bearer\s+)[A-Za-z0-9._~+/=-]{12,}/gi;
+/** NAME=value or NAME: value, where NAME looks like a secret variable. */
+const ENV_ASSIGN = /\b([A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIALS?)[A-Z0-9_]*)(\s*[=:]\s*)("[^"\n]*"|'[^'\n]*'|[^\s"',;]+)/g;
+export function redactString(input) {
+    let out = input;
+    for (const re of TOKEN_PATTERNS)
+        out = out.replace(re, REDACTED);
+    out = out.replace(BEARER, `$1${REDACTED}`);
+    out = out.replace(ENV_ASSIGN, (match, name, sep, value) => value === REDACTED || value === `"${REDACTED}"` ? match : `${name}${sep}${REDACTED}`);
+    return out;
+}
+/** Deep-redacts strings and values under secret-looking object keys. Returns the changed flag. */
+export function redactValue(value) {
+    if (typeof value === 'string') {
+        const next = redactString(value);
+        return { value: next, changed: next !== value };
+    }
+    if (Array.isArray(value)) {
+        let changed = false;
+        const out = value.map((item) => {
+            const r = redactValue(item);
+            changed = changed || r.changed;
+            return r.value;
+        });
+        return { value: out, changed };
+    }
+    if (value !== null && typeof value === 'object') {
+        let changed = false;
+        const out = {};
+        for (const [key, v] of Object.entries(value)) {
+            if (SECRET_NAME.test(key) && typeof v === 'string' && v !== '' && v !== REDACTED) {
+                out[key] = REDACTED;
+                changed = true;
+                continue;
+            }
+            const r = redactValue(v);
+            changed = changed || r.changed;
+            out[key] = r.value;
+        }
+        return { value: out, changed };
+    }
+    return { value, changed: false };
+}
+/** Signer from a PKCS8 PEM Ed25519 private key. */
+export function createSigner(privateKeyPem) {
+    const privateKey = createPrivateKey(privateKeyPem);
+    if (privateKey.asymmetricKeyType !== 'ed25519')
+        throw new Error('Receipt signing key must be Ed25519');
+    const publicKey = createPublicKey(privateKey).export({ type: 'spki', format: 'der' }).toString('base64');
+    return {
+        publicKey,
+        sign: (hash) => edSign(null, Buffer.from(hash, 'utf-8'), privateKey).toString('base64'),
+    };
+}
+export function loadSignerFromFile(path) {
+    return createSigner(readFileSync(path, 'utf-8'));
+}
+/** Default location: <projectRoot>/.profclaw/runs/<runId>/receipt.jsonl (env PROFCLAW_RECEIPT_PATH overrides). */
+export function defaultReceiptPath(projectRoot, runId, env = process.env) {
+    const override = env['PROFCLAW_RECEIPT_PATH']?.trim();
+    return override ? override : join(projectRoot, '.profclaw', 'runs', runId, 'receipt.jsonl');
+}
+export class ReceiptWriter {
+    path;
+    seq = 0;
+    prev = GENESIS_HASH;
+    ended = false;
+    signer;
+    redact;
+    now;
+    constructor(options) {
+        this.path = options.path;
+        this.signer = options.signer;
+        this.redact = options.redact ?? true;
+        this.now = options.now ?? (() => new Date());
+        mkdirSync(dirname(this.path), { recursive: true });
+        // Append-only and one receipt per file: refuse to extend an existing file.
+        if (existsSync(this.path))
+            throw new Error(`Receipt already exists: ${this.path}`);
+        writeFileSync(this.path, '', { flag: 'wx' });
+    }
+    get lastHash() {
+        return this.prev;
+    }
+    append(type, data) {
+        if (this.ended)
+            throw new Error('Receipt already ended (run_end written)');
+        let payload = data;
+        if (this.redact) {
+            const r = redactValue(data);
+            payload = r.value;
+            if (type === 'tool_call' && r.changed) {
+                payload['redacted'] = true;
+            }
+        }
+        const base = {
+            v: RECEIPT_VERSION,
+            seq: this.seq,
+            ts: this.now().toISOString(),
+            type,
+            data: payload,
+            prev: this.prev,
+        };
+        const hash = computeEventHash(base);
+        const event = { ...base, hash };
+        if (type === 'run_end' && this.signer) {
+            const signature = {
+                alg: 'ed25519',
+                publicKey: this.signer.publicKey,
+                sig: this.signer.sign(hash),
+            };
+            event['signature'] = signature;
+        }
+        // Canonical text per line; hash and signature are members like any other.
+        appendFileSync(this.path, `${canonicalJson(event)}\n`, 'utf-8');
+        this.seq++;
+        this.prev = hash;
+        if (type === 'run_end')
+            this.ended = true;
+        return event;
+    }
+}
+//# sourceMappingURL=receipt-writer.js.map

package/dist/agents/result-store.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Result Store
+ *
+ * Manages large tool results by spilling them to disk when they exceed the
+ * inline size limit. This prevents context windows from being flooded by
+ * large tool outputs (e.g. file reads, API dumps).
+ */
+export interface StoredResult {
+    /** Summary string (or full result if small enough) that goes into context */
+    inline: string;
+    /** Path to the temp file containing the full result, if spilled */
+    fullPath?: string;
+    /** Original serialized byte length */
+    originalSize: number;
+    /** Whether the stored content was truncated */
+    truncated: boolean;
+}
+export declare class ResultStore {
+    private results;
+    private tempDir;
+    constructor(sessionId: string);
+    /**
+     * Store a tool result. Small results stay inline; large results spill to
+     * disk and return a summary pointing to the temp file.
+     */
+    store(toolCallId: string, result: unknown): Promise<StoredResult>;
+    /**
+     * Retrieve a previously stored result by its tool call ID.
+     */
+    retrieve(toolCallId: string): StoredResult | undefined;
+    /**
+     * Delete all temp files created during this session.
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Remove stale result directories (e.g. from crashed runs) older than the TTL.
+     * TTL comes from PROFCLAW_RESULT_STORE_TTL_MS (default 24h). Returns the
+     * number of directories removed. Never throws.
+     */
+    static sweepStale(ttlMs?: number, baseDir?: string, now?: number): Promise<number>;
+    private writeTempFile;
+}
+//# sourceMappingURL=result-store.d.ts.map

package/dist/agents/result-store.js

@@ -0,0 +1,145 @@
+/**
+ * Result Store
+ *
+ * Manages large tool results by spilling them to disk when they exceed the
+ * inline size limit. This prevents context windows from being flooded by
+ * large tool outputs (e.g. file reads, API dumps).
+ */
+import { writeFile, unlink, mkdir, readdir, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { logger } from "../utils/logger.js";
+/** Results <= 50KB stay inline in the context window */
+const MAX_INLINE_SIZE = 50_000;
+/** Results > 5MB get truncated before saving */
+const MAX_TOTAL_SIZE = 5_000_000;
+/** Number of chars to include in the inline preview */
+const PREVIEW_LENGTH = 500;
+const TEMP_DIR_PREFIX = "profclaw-results-";
+/** Stale temp dir TTL, env-configurable (PROFCLAW_RESULT_STORE_TTL_MS, default 24h) */
+function getResultStoreTtlMs() {
+    const parsed = Number.parseInt(process.env.PROFCLAW_RESULT_STORE_TTL_MS ?? "", 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 24 * 60 * 60 * 1000;
+}
+export class ResultStore {
+    results = new Map();
+    tempDir;
+    constructor(sessionId) {
+        this.tempDir = join(tmpdir(), `${TEMP_DIR_PREFIX}${sessionId}`);
+    }
+    /**
+     * Store a tool result. Small results stay inline; large results spill to
+     * disk and return a summary pointing to the temp file.
+     */
+    async store(toolCallId, result) {
+        const serialized = JSON.stringify(result);
+        const size = Buffer.byteLength(serialized, "utf8");
+        let stored;
+        if (size <= MAX_INLINE_SIZE) {
+            // Small enough — keep it in context as-is
+            stored = {
+                inline: serialized,
+                originalSize: size,
+                truncated: false,
+            };
+        }
+        else {
+            // Needs to spill to disk
+            const truncated = size > MAX_TOTAL_SIZE;
+            const content = truncated
+                ? serialized.slice(0, MAX_TOTAL_SIZE)
+                : serialized;
+            const filePath = await this.writeTempFile(toolCallId, content);
+            const preview = serialized.slice(0, PREVIEW_LENGTH);
+            const sizeLabel = truncated
+                ? `${MAX_TOTAL_SIZE.toLocaleString()} bytes (truncated from ${size.toLocaleString()} bytes)`
+                : `${size.toLocaleString()} bytes`;
+            stored = {
+                inline: `[Result stored: ${sizeLabel}. Use retrieve_result tool to access full data. Preview: ${preview}...]`,
+                fullPath: filePath,
+                originalSize: size,
+                truncated,
+            };
+            logger.debug("[ResultStore] Spilled large result to disk", {
+                toolCallId,
+                size,
+                truncated,
+                filePath,
+            });
+        }
+        this.results.set(toolCallId, stored);
+        return stored;
+    }
+    /**
+     * Retrieve a previously stored result by its tool call ID.
+     */
+    retrieve(toolCallId) {
+        return this.results.get(toolCallId);
+    }
+    /**
+     * Delete all temp files created during this session.
+     */
+    async cleanup() {
+        const deletions = [];
+        for (const [id, stored] of this.results.entries()) {
+            if (stored.fullPath) {
+                deletions.push(unlink(stored.fullPath).catch((err) => {
+                    logger.warn("[ResultStore] Failed to delete temp file", {
+                        id,
+                        path: stored.fullPath,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }));
+            }
+        }
+        await Promise.all(deletions);
+        this.results.clear();
+        logger.debug("[ResultStore] Cleaned up temp files", {
+            count: deletions.length,
+        });
+    }
+    /**
+     * Remove stale result directories (e.g. from crashed runs) older than the TTL.
+     * TTL comes from PROFCLAW_RESULT_STORE_TTL_MS (default 24h). Returns the
+     * number of directories removed. Never throws.
+     */
+    static async sweepStale(ttlMs = getResultStoreTtlMs(), baseDir = tmpdir(), now = Date.now()) {
+        let removed = 0;
+        try {
+            const entries = await readdir(baseDir);
+            for (const name of entries) {
+                if (!name.startsWith(TEMP_DIR_PREFIX))
+                    continue;
+                const dir = join(baseDir, name);
+                try {
+                    const info = await stat(dir);
+                    if (!info.isDirectory() || now - info.mtimeMs <= ttlMs)
+                        continue;
+                    await rm(dir, { recursive: true, force: true });
+                    removed++;
+                }
+                catch (err) {
+                    logger.warn("[ResultStore] Failed to sweep stale dir", {
+                        dir,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+        }
+        catch (err) {
+            logger.warn("[ResultStore] Stale sweep failed", {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        return removed;
+    }
+    async writeTempFile(toolCallId, content) {
+        await mkdir(this.tempDir, { recursive: true });
+        const fileName = `${toolCallId}-${randomUUID()}.json`;
+        const filePath = join(this.tempDir, fileName);
+        await writeFile(filePath, content, "utf8");
+        return filePath;
+    }
+}
+//# sourceMappingURL=result-store.js.map

package/dist/agents/session-diff.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Session Diff Tracker
+ *
+ * Records original file contents before the agent makes any edits so that
+ * a unified diff of all changes can be produced at any time (e.g. /diff).
+ */
+export type FileChangeStatus = 'modified' | 'created' | 'deleted';
+export declare class SessionDiffTracker {
+    private originals;
+    constructor();
+    /**
+     * Record the original content of a file before the agent touches it.
+     * Only the first call per file path is honoured — subsequent calls are
+     * ignored so the "before" state remains the pre-session state.
+     */
+    recordOriginal(filePath: string, content: string): void;
+    /**
+     * Record that a file was created during this session (it did not exist before).
+     */
+    recordCreated(filePath: string): void;
+    /**
+     * Generate a unified diff for all modified files.
+     * Returns an empty string if nothing has changed.
+     */
+    generateDiff(): Promise<string>;
+    /**
+     * Return a list of changed files with their status.
+     */
+    getChangedFiles(): Array<{
+        path: string;
+        status: FileChangeStatus;
+    }>;
+    /**
+     * Generate a unified diff for a single file.
+     * Returns an empty string if the file content is unchanged.
+     */
+    getFileDiff(filePath: string): Promise<string>;
+}
+/**
+ * Returns the process-level singleton SessionDiffTracker.
+ */
+export declare function getSessionDiffTracker(): SessionDiffTracker;
+/**
+ * Produce a minimal edit script using the Myers diff algorithm.
+ * Returns an array of [type, line] tuples where type is '+', '-', or '='.
+ */
+/** Myers shortest edit script. Exported for tests. */
+export declare function shortestEditScript(oldLines: string[], newLines: string[]): Array<['+' | '-' | '=', string]>;
+//# sourceMappingURL=session-diff.d.ts.map

package/dist/agents/session-diff.js

@@ -0,0 +1,249 @@
+/**
+ * Session Diff Tracker
+ *
+ * Records original file contents before the agent makes any edits so that
+ * a unified diff of all changes can be produced at any time (e.g. /diff).
+ */
+import fs from 'node:fs/promises';
+let defaultTracker = null;
+export class SessionDiffTracker {
+    originals;
+    constructor() {
+        this.originals = new Map();
+    }
+    /**
+     * Record the original content of a file before the agent touches it.
+     * Only the first call per file path is honoured — subsequent calls are
+     * ignored so the "before" state remains the pre-session state.
+     */
+    recordOriginal(filePath, content) {
+        if (!this.originals.has(filePath)) {
+            this.originals.set(filePath, { originalContent: content, created: false });
+        }
+    }
+    /**
+     * Record that a file was created during this session (it did not exist before).
+     */
+    recordCreated(filePath) {
+        if (!this.originals.has(filePath)) {
+            this.originals.set(filePath, { originalContent: null, created: true });
+        }
+    }
+    /**
+     * Generate a unified diff for all modified files.
+     * Returns an empty string if nothing has changed.
+     */
+    async generateDiff() {
+        const parts = [];
+        for (const filePath of this.originals.keys()) {
+            const diff = await this.getFileDiff(filePath);
+            if (diff) {
+                parts.push(diff);
+            }
+        }
+        return parts.join('\n');
+    }
+    /**
+     * Return a list of changed files with their status.
+     */
+    getChangedFiles() {
+        const result = [];
+        for (const [filePath, tracked] of this.originals.entries()) {
+            if (tracked.created) {
+                result.push({ path: filePath, status: 'created' });
+            }
+            else {
+                result.push({ path: filePath, status: 'modified' });
+            }
+        }
+        return result;
+    }
+    /**
+     * Generate a unified diff for a single file.
+     * Returns an empty string if the file content is unchanged.
+     */
+    async getFileDiff(filePath) {
+        const tracked = this.originals.get(filePath);
+        if (!tracked)
+            return '';
+        let currentContent;
+        try {
+            currentContent = await fs.readFile(filePath, 'utf-8');
+        }
+        catch {
+            currentContent = null;
+        }
+        const originalContent = tracked.originalContent ?? '';
+        const newContent = currentContent ?? '';
+        if (originalContent === newContent)
+            return '';
+        const aLabel = tracked.created ? '/dev/null' : `a/${filePath}`;
+        const bLabel = currentContent === null ? '/dev/null' : `b/${filePath}`;
+        return buildUnifiedDiff(aLabel, bLabel, originalContent, newContent);
+    }
+}
+/**
+ * Returns the process-level singleton SessionDiffTracker.
+ */
+export function getSessionDiffTracker() {
+    if (!defaultTracker) {
+        defaultTracker = new SessionDiffTracker();
+    }
+    return defaultTracker;
+}
+// ---------------------------------------------------------------------------
+// Minimal unified diff implementation (no external dependencies)
+// ---------------------------------------------------------------------------
+function buildUnifiedDiff(aLabel, bLabel, oldText, newText) {
+    const oldLines = oldText === '' ? [] : oldText.split('\n');
+    const newLines = newText === '' ? [] : newText.split('\n');
+    const hunks = computeHunks(oldLines, newLines);
+    if (hunks.length === 0)
+        return '';
+    const header = [`--- ${aLabel}`, `+++ ${bLabel}`];
+    const body = hunks.map(renderHunk);
+    return [...header, ...body].join('\n') + '\n';
+}
+const CONTEXT = 3;
+function computeHunks(oldLines, newLines) {
+    // Myers-style LCS diff
+    const edit = shortestEditScript(oldLines, newLines);
+    // Group edits into hunks with context
+    const hunks = [];
+    // Build flat edit list
+    const ops = [];
+    let oi = 0;
+    let ni = 0;
+    for (const [type, content] of edit) {
+        if (type === '=') {
+            ops.push({ type: '=', oldIdx: oi, newIdx: ni, content });
+            oi++;
+            ni++;
+        }
+        else if (type === '-') {
+            ops.push({ type: '-', oldIdx: oi, newIdx: ni, content });
+            oi++;
+        }
+        else {
+            ops.push({ type: '+', oldIdx: oi, newIdx: ni, content });
+            ni++;
+        }
+    }
+    // Find change ranges
+    const changeIndices = ops
+        .map((op, i) => (op.type !== '=' ? i : -1))
+        .filter((i) => i !== -1);
+    if (changeIndices.length === 0)
+        return [];
+    // Merge ranges with context into hunks
+    let start = Math.max(0, changeIndices[0] - CONTEXT);
+    let end = Math.min(ops.length - 1, changeIndices[0] + CONTEXT);
+    const ranges = [];
+    for (let k = 1; k < changeIndices.length; k++) {
+        const ci = changeIndices[k];
+        if (ci - CONTEXT <= end + 1) {
+            end = Math.min(ops.length - 1, ci + CONTEXT);
+        }
+        else {
+            ranges.push([start, end]);
+            start = Math.max(0, ci - CONTEXT);
+            end = Math.min(ops.length - 1, ci + CONTEXT);
+        }
+    }
+    ranges.push([start, end]);
+    for (const [s, e] of ranges) {
+        const slice = ops.slice(s, e + 1);
+        const oldStart = (slice.find((op) => op.type !== '+')?.oldIdx ?? 0) + 1;
+        const newStart = (slice.find((op) => op.type !== '-')?.newIdx ?? 0) + 1;
+        const oldCount = slice.filter((op) => op.type !== '+').length;
+        const newCount = slice.filter((op) => op.type !== '-').length;
+        const header = `@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`;
+        const lines = slice.map((op) => {
+            if (op.type === '=')
+                return ` ${op.content}`;
+            if (op.type === '-')
+                return `-${op.content}`;
+            return `+${op.content}`;
+        });
+        hunks.push({ header, lines });
+    }
+    return hunks;
+}
+function renderHunk(hunk) {
+    return [hunk.header, ...hunk.lines].join('\n');
+}
+/**
+ * Produce a minimal edit script using the Myers diff algorithm.
+ * Returns an array of [type, line] tuples where type is '+', '-', or '='.
+ */
+/** Myers shortest edit script. Exported for tests. */
+export function shortestEditScript(oldLines, newLines) {
+    const n = oldLines.length;
+    const m = newLines.length;
+    const max = n + m;
+    if (max === 0)
+        return [];
+    // v[k] stores the furthest-reaching x position for diagonal k
+    const v = new Array(2 * max + 1).fill(0);
+    const trace = [];
+    outer: for (let d = 0; d <= max; d++) {
+        trace.push([...v]);
+        for (let k = -d; k <= d; k += 2) {
+            const ki = k + max;
+            let x;
+            if (k === -d || (k !== d && v[ki - 1] < v[ki + 1])) {
+                x = v[ki + 1];
+            }
+            else {
+                x = v[ki - 1] + 1;
+            }
+            let y = x - k;
+            while (x < n && y < m && oldLines[x] === newLines[y]) {
+                x++;
+                y++;
+            }
+            v[ki] = x;
+            if (x >= n && y >= m) {
+                break outer;
+            }
+        }
+    }
+    // Backtrack to reconstruct the edit path
+    const edits = [];
+    let x = n;
+    let y = m;
+    for (let d = trace.length - 1; d >= 0; d--) {
+        const vPrev = trace[d];
+        const k = x - y;
+        const down = k === -d || (k !== d && vPrev[k - 1 + max] < vPrev[k + 1 + max]);
+        const prevK = down ? k + 1 : k - 1;
+        const prevX = vPrev[prevK + max];
+        const prevY = prevX - prevK;
+        // Follow the diagonal (matching lines) back to where this round's edit ended.
+        while (x > prevX && y > prevY) {
+            edits.unshift(['=', oldLines[x - 1]]);
+            x--;
+            y--;
+        }
+        if (d > 0) {
+            if (down) {
+                edits.unshift(['+', newLines[y - 1]]);
+                y--;
+            }
+            else {
+                edits.unshift(['-', oldLines[x - 1]]);
+                x--;
+            }
+        }
+    }
+    while (x > 0) {
+        edits.unshift(['-', oldLines[x - 1]]);
+        x--;
+    }
+    while (y > 0) {
+        edits.unshift(['+', newLines[y - 1]]);
+        y--;
+    }
+    return edits;
+}
+//# sourceMappingURL=session-diff.js.map