@canonmsg/claude-code-plugin 0.15.2 → 0.19.1

package/dist/approval-diff.d.ts

@@ -0,0 +1,15 @@
+import { type CanonUnifiedDiff } from '@canonmsg/core';
+/** Read a file's text, or null when the file does not exist. */
+export type ApprovalDiffReadFile = (filePath: string) => Promise<string | null>;
+export interface SynthesizeApprovalDiffOptions {
+    /** Session working directory — resolves relative tool paths and shortens display paths. */
+    cwd?: string;
+    readFile: ApprovalDiffReadFile;
+}
+/**
+ * Synthesize a CanonUnifiedDiff preview for a pending Edit/MultiEdit/Write
+ * tool call. Returns undefined for any other tool (including NotebookEdit —
+ * cell edits do not map onto file hunks) and whenever the post-image cannot
+ * be derived faithfully. Output is size-disciplined via truncateUnifiedDiff.
+ */
+export declare function synthesizeClaudeApprovalDiff(toolName: string, toolInput: Record<string, unknown>, options: SynthesizeApprovalDiffOptions): Promise<CanonUnifiedDiff | undefined>;

package/dist/approval-diff.js

@@ -0,0 +1,287 @@
+import { isAbsolute, join, relative } from 'node:path';
+import { sanitizeUnifiedDiffForSharing, truncateUnifiedDiff, } from '@canonmsg/core';
+/** Unified-hunk context lines on either side of a change (git default). */
+const HUNK_CONTEXT_LINES = 3;
+/**
+ * Skip synthesis entirely for sources beyond this size — the card budget
+ * (UNIFIED_DIFF_MAX_FILE_BYTES) would clip the output to a sliver anyway, and
+ * diffing multi-megabyte files inside canUseTool would stall the approval.
+ */
+const MAX_SOURCE_CHARS = 2 * 1024 * 1024;
+/**
+ * LCS cost ceiling (old lines × new lines). Beyond it the changed middle is
+ * emitted as one delete-all/add-all block instead of a minimal diff.
+ */
+const MAX_LCS_CELLS = 1_000_000;
+const NO_NEWLINE_MARKER = '\';
+/**
+ * Synthesize a CanonUnifiedDiff preview for a pending Edit/MultiEdit/Write
+ * tool call. Returns undefined for any other tool (including NotebookEdit —
+ * cell edits do not map onto file hunks) and whenever the post-image cannot
+ * be derived faithfully. Output is size-disciplined via truncateUnifiedDiff.
+ */
+export async function synthesizeClaudeApprovalDiff(toolName, toolInput, options) {
+    const normalized = toolName.trim().toLowerCase();
+    if (normalized !== 'edit' && normalized !== 'multiedit' && normalized !== 'write') {
+        return undefined;
+    }
+    const filePath = typeof toolInput.file_path === 'string' ? toolInput.file_path.trim() : '';
+    if (!filePath)
+        return undefined;
+    const resolvedPath = isAbsolute(filePath)
+        ? filePath
+        : options.cwd
+            ? join(options.cwd, filePath)
+            : filePath;
+    const preImage = await options.readFile(resolvedPath);
+    if (preImage !== null && !isDiffableText(preImage))
+        return undefined;
+    let postImage;
+    let status;
+    if (normalized === 'write') {
+        if (typeof toolInput.content !== 'string')
+            return undefined;
+        postImage = toolInput.content;
+        status = preImage === null ? 'created' : 'modified';
+    }
+    else {
+        // Edit / MultiEdit need a pre-image to splice into; if the file is absent
+        // the tool itself will fail, so there is no change to preview.
+        if (preImage === null)
+            return undefined;
+        const edits = normalized === 'edit'
+            ? parseSingleEdit(toolInput)
+            : parseMultiEdits(toolInput);
+        if (!edits)
+            return undefined;
+        const spliced = applyEdits(preImage, edits);
+        if (spliced === null)
+            return undefined;
+        postImage = spliced;
+        status = 'modified';
+    }
+    if (!isDiffableText(postImage))
+        return undefined;
+    const oldText = preImage ?? '';
+    if (oldText === postImage)
+        return undefined;
+    const hunks = buildUnifiedHunks(oldText, postImage);
+    if (!hunks)
+        return undefined;
+    // Sanitize before truncating so byte budgets are spent on hunks that ship —
+    // secret-bearing paths and private-key blocks lose their hunk text here.
+    return truncateUnifiedDiff(sanitizeUnifiedDiffForSharing({
+        files: [{
+                path: toDisplayPath(resolvedPath, options.cwd),
+                status,
+                diff: hunks.text,
+                additions: hunks.additions,
+                deletions: hunks.deletions,
+            }],
+    }));
+}
+// ── Edit splicing ────────────────────────────────────────────────────
+function parseSingleEdit(toolInput) {
+    const edit = parseEdit(toolInput);
+    return edit ? [edit] : null;
+}
+function parseMultiEdits(toolInput) {
+    if (!Array.isArray(toolInput.edits) || toolInput.edits.length === 0)
+        return null;
+    const edits = [];
+    for (const entry of toolInput.edits) {
+        if (!entry || typeof entry !== 'object')
+            return null;
+        const edit = parseEdit(entry);
+        if (!edit)
+            return null;
+        edits.push(edit);
+    }
+    return edits;
+}
+function parseEdit(value) {
+    const oldString = typeof value.old_string === 'string' ? value.old_string : null;
+    const newString = typeof value.new_string === 'string' ? value.new_string : null;
+    // Empty old_string is a create-or-append special case with tool-version
+    // dependent semantics — skip rather than guess at the post-image.
+    if (!oldString || newString === null)
+        return null;
+    return { oldString, newString, replaceAll: value.replace_all === true };
+}
+/** Apply edits sequentially (MultiEdit semantics). Null when any edit cannot apply. */
+function applyEdits(text, edits) {
+    let current = text;
+    for (const edit of edits) {
+        current = applyEdit(current, edit);
+        if (current === null)
+            return null;
+    }
+    return current;
+}
+function applyEdit(text, edit) {
+    if (edit.oldString === edit.newString)
+        return null;
+    const first = text.indexOf(edit.oldString);
+    if (first === -1)
+        return null;
+    if (edit.replaceAll) {
+        return text.split(edit.oldString).join(edit.newString);
+    }
+    // The Edit tool requires a unique match without replace_all; mirror that so
+    // the preview never shows a splice the tool would refuse to make.
+    if (text.indexOf(edit.oldString, first + edit.oldString.length) !== -1)
+        return null;
+    return text.slice(0, first) + edit.newString + text.slice(first + edit.oldString.length);
+}
+function isDiffableText(text) {
+    return text.length <= MAX_SOURCE_CHARS && !text.includes('\u0000');
+}
+/**
+ * Split into lines keeping CRLF intact: we split on '\n' only, so '\r' stays
+ * part of the line text and survives into the hunk verbatim. The trailing-
+ * newline state rides on the final line so "a\n" vs "a" still diffs.
+ */
+function splitDiffLines(text) {
+    if (text.length === 0)
+        return [];
+    const parts = text.split('\n');
+    const trailingNewline = parts[parts.length - 1] === '';
+    if (trailingNewline)
+        parts.pop();
+    return parts.map((line, index) => ({
+        text: line,
+        noEol: !trailingNewline && index === parts.length - 1,
+    }));
+}
+function sameLine(a, b) {
+    return a.text === b.text && a.noEol === b.noEol;
+}
+/** Common prefix/suffix trim, then a bounded LCS over the changed middle. */
+function diffLines(oldLines, newLines) {
+    let prefix = 0;
+    const maxPrefix = Math.min(oldLines.length, newLines.length);
+    while (prefix < maxPrefix && sameLine(oldLines[prefix], newLines[prefix]))
+        prefix += 1;
+    let suffix = 0;
+    while (suffix < maxPrefix - prefix
+        && sameLine(oldLines[oldLines.length - 1 - suffix], newLines[newLines.length - 1 - suffix]))
+        suffix += 1;
+    return [
+        ...oldLines.slice(0, prefix).map((line) => ({ kind: ' ', line })),
+        ...diffMiddle(oldLines.slice(prefix, oldLines.length - suffix), newLines.slice(prefix, newLines.length - suffix)),
+        ...oldLines.slice(oldLines.length - suffix).map((line) => ({ kind: ' ', line })),
+    ];
+}
+function diffMiddle(oldLines, newLines) {
+    const replaceAll = () => [
+        ...oldLines.map((line) => ({ kind: '-', line })),
+        ...newLines.map((line) => ({ kind: '+', line })),
+    ];
+    if (oldLines.length === 0 || newLines.length === 0)
+        return replaceAll();
+    if (oldLines.length * newLines.length > MAX_LCS_CELLS)
+        return replaceAll();
+    // Classic LCS-length table, walked forward to interleave -/+ runs.
+    const cols = newLines.length + 1;
+    const table = new Uint32Array((oldLines.length + 1) * cols);
+    for (let i = oldLines.length - 1; i >= 0; i -= 1) {
+        for (let j = newLines.length - 1; j >= 0; j -= 1) {
+            table[i * cols + j] = sameLine(oldLines[i], newLines[j])
+                ? table[(i + 1) * cols + j + 1] + 1
+                : Math.max(table[(i + 1) * cols + j], table[i * cols + j + 1]);
+        }
+    }
+    const ops = [];
+    let i = 0;
+    let j = 0;
+    while (i < oldLines.length && j < newLines.length) {
+        if (sameLine(oldLines[i], newLines[j])) {
+            ops.push({ kind: ' ', line: oldLines[i] });
+            i += 1;
+            j += 1;
+        }
+        else if (table[(i + 1) * cols + j] >= table[i * cols + j + 1]) {
+            ops.push({ kind: '-', line: oldLines[i] });
+            i += 1;
+        }
+        else {
+            ops.push({ kind: '+', line: newLines[j] });
+            j += 1;
+        }
+    }
+    while (i < oldLines.length)
+        ops.push({ kind: '-', line: oldLines[i++] });
+    while (j < newLines.length)
+        ops.push({ kind: '+', line: newLines[j++] });
+    return ops;
+}
+/**
+ * Render diff ops as unified hunk text with @@ headers and git-style framing
+ * (counts of 1 omitted, "" markers). Null when the
+ * texts are line-identical.
+ */
+function buildUnifiedHunks(oldText, newText) {
+    const ops = diffLines(splitDiffLines(oldText), splitDiffLines(newText));
+    // Old/new line number of each op's position (1-based, "next line to emit").
+    const oldPos = new Array(ops.length);
+    const newPos = new Array(ops.length);
+    let oldLine = 1;
+    let newLine = 1;
+    ops.forEach((op, index) => {
+        oldPos[index] = oldLine;
+        newPos[index] = newLine;
+        if (op.kind !== '+')
+            oldLine += 1;
+        if (op.kind !== '-')
+            newLine += 1;
+    });
+    const changed = ops.flatMap((op, index) => (op.kind === ' ' ? [] : [index]));
+    if (changed.length === 0)
+        return null;
+    // Group changes into hunks: expand by the context window, merge overlaps.
+    const ranges = [];
+    for (const index of changed) {
+        const start = Math.max(0, index - HUNK_CONTEXT_LINES);
+        const end = Math.min(ops.length - 1, index + HUNK_CONTEXT_LINES);
+        const last = ranges[ranges.length - 1];
+        if (last && start <= last.end + 1) {
+            last.end = end;
+        }
+        else {
+            ranges.push({ start, end });
+        }
+    }
+    let additions = 0;
+    let deletions = 0;
+    const lines = [];
+    for (const range of ranges) {
+        const hunkOps = ops.slice(range.start, range.end + 1);
+        const oldCount = hunkOps.filter((op) => op.kind !== '+').length;
+        const newCount = hunkOps.filter((op) => op.kind !== '-').length;
+        // Zero-count sides anchor on the line BEFORE the hunk (git convention).
+        const oldStart = oldCount > 0 ? oldPos[range.start] : oldPos[range.start] - 1;
+        const newStart = newCount > 0 ? newPos[range.start] : newPos[range.start] - 1;
+        lines.push(`@@ -${formatHunkSide(oldStart, oldCount)} +${formatHunkSide(newStart, newCount)} @@`);
+        for (const op of hunkOps) {
+            if (op.kind === '+')
+                additions += 1;
+            if (op.kind === '-')
+                deletions += 1;
+            lines.push(op.kind + op.line.text);
+            if (op.line.noEol)
+                lines.push(NO_NEWLINE_MARKER);
+        }
+    }
+    return { text: lines.join('\n'), additions, deletions };
+}
+function formatHunkSide(start, count) {
+    return count === 1 ? `${start}` : `${start},${count}`;
+}
+function toDisplayPath(filePath, cwd) {
+    if (!cwd || !isAbsolute(filePath) || !isAbsolute(cwd))
+        return filePath;
+    const rel = relative(cwd, filePath);
+    if (!rel || rel.startsWith('..') || isAbsolute(rel))
+        return filePath;
+    return rel;
+}

package/dist/host.d.ts

@@ -1,2 +1,11 @@
 #!/usr/bin/env node
+import { type SDKControlReloadPluginsResponse } from '@anthropic-ai/claude-agent-sdk';
+import { type CanonRuntimeCommandDescriptor } from '@canonmsg/core';
+/**
+ * Claude Code's own slash commands (built-ins, plugins, project .claude/
+ * commands) are executable when sent as prompt text, so the runtime's command
+ * inventory is exposed as composer slash entries that pass the raw slash text
+ * through. Canon-injected aliases keep precedence over native names.
+ */
+export declare function buildNativeSlashCommandDescriptors(native: SDKControlReloadPluginsResponse['commands'], reservedAliases: ReadonlySet<string>): CanonRuntimeCommandDescriptor[];
 export declare function main(): Promise<void>;