toolcraft 0.0.98 → 0.0.100

package/composition.json

@@ -48,7 +48,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.98",
+      "version": "0.0.100",
       "license": "MIT"
     },
     {

package/dist/composition.json

@@ -48,7 +48,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.98",
+      "version": "0.0.100",
       "license": "MIT"
     },
     {

package/dist/file-change-renderer.d.ts

@@ -0,0 +1,9 @@
+import { type FileChange, type FileChangeDisplayMode } from "toolcraft-design";
+import type { Renderers } from "./index.js";
+export interface FileChangeResult {
+    changes: readonly FileChange[];
+}
+export interface FileChangeRendererOptions {
+    mode?: FileChangeDisplayMode;
+}
+export declare function createFileChangeRenderers<TResult extends FileChangeResult = FileChangeResult>(options?: FileChangeRendererOptions): Renderers<TResult>;

package/dist/file-change-renderer.js

@@ -0,0 +1,10 @@
+import { renderFileChanges } from "toolcraft-design";
+export function createFileChangeRenderers(options = {}) {
+    return {
+        rich: (result) => {
+            process.stdout.write(`${renderFileChanges(result.changes, { mode: options.mode })}\n`);
+        },
+        markdown: (result) => renderFileChanges(result.changes, { mode: options.mode, format: "markdown" }),
+        json: (result) => result
+    };
+}

package/dist/human-in-loop/approval-tasks.d.ts

@@ -1,11 +1,14 @@
 import type { OpenTaskListOptions, TaskList, Tasks } from "@poe-code/task-list";
 import type { HumanInLoopPending, HumanInLoopRuntimeOptions } from "./types.js";
+import { type ApprovalPlanValue } from "./plan-hash.js";
 export interface ApprovalPayload {
     approvalId?: string;
     commandPath: string;
     params: Record<string, unknown>;
     message: string;
     declineInputPrompt?: string | null;
+    plan?: ApprovalPlanValue;
+    planHash?: string;
     enqueuedAt?: string;
     pid?: number | null;
     result?: unknown;

package/dist/human-in-loop/approval-tasks.js

@@ -2,6 +2,7 @@ import { TaskAlreadyExistsError, TaskNotFoundError, openTaskList } from "@poe-co
 import { randomBytes } from "node:crypto";
 import { UserError } from "../user-error.js";
 import { approvalStateMachine } from "./state-machine.js";
+import { isApprovalPlanValue } from "./plan-hash.js";
 const DEFAULT_LIST_NAME = "approvals";
 const openedTaskListsByRuntime = new WeakMap();
 const validatedListsByRuntime = new WeakMap();
@@ -84,28 +85,36 @@ function isListValidated(runtimeOptions, listName) {
 }
 function createApprovalRecord(payload, enqueuedAt) {
     const approvalId = `${enqueuedAt.slice(0, 19).replaceAll(":", "-")}-${randomBytes(3).toString("hex")}`;
-    return {
+    const metadata = {
+        schemaVersion: 1,
+        approvalId,
+        commandPath: payload.commandPath,
+        params: payload.params,
+        message: payload.message,
+        declineInputPrompt: payload.declineInputPrompt ?? null,
+        enqueuedAt,
+        pid: null,
+        result: null,
+        error: null
+    };
+    const pending = {
+        status: "pending-approval",
+        approvalId,
+        message: payload.message,
+        enqueuedAt
+    };
+    const approval = {
         approvalId,
         name: `${payload.commandPath} (${enqueuedAt})`,
-        metadata: {
-            schemaVersion: 1,
-            approvalId,
-            commandPath: payload.commandPath,
-            params: payload.params,
-            message: payload.message,
-            declineInputPrompt: payload.declineInputPrompt ?? null,
-            enqueuedAt,
-            pid: null,
-            result: null,
-            error: null
-        },
-        pending: {
-            status: "pending-approval",
-            approvalId,
-            message: payload.message,
-            enqueuedAt
-        }
+        metadata,
+        pending
     };
+    if (payload.plan !== undefined && payload.planHash !== undefined) {
+        approval.metadata.plan = payload.plan;
+        approval.metadata.planHash = payload.planHash;
+        approval.pending.planHash = payload.planHash;
+    }
+    return approval;
 }
 async function createApprovalTask(tasks, approval) {
     await tasks.create({
@@ -198,6 +207,8 @@ function approvalPayloadFromTask(task) {
         declineInputPrompt: typeof metadata.declineInputPrompt === "string" || metadata.declineInputPrompt === null
             ? metadata.declineInputPrompt
             : undefined,
+        plan: isApprovalPlanValue(metadata.plan) ? metadata.plan : undefined,
+        planHash: typeof metadata.planHash === "string" ? metadata.planHash : undefined,
         enqueuedAt: metadata.enqueuedAt,
         pid: typeof metadata.pid === "number" || metadata.pid === null ? metadata.pid : undefined,
         result: metadata.result,

package/dist/human-in-loop/config.js

@@ -12,6 +12,9 @@ export function validateHumanInLoopOnDefine(config) {
     if (typeof config.humanInLoop.message !== "function") {
         throw new Error(`${label} '${config.name}': humanInLoop.message must be a function`);
     }
+    if (config.humanInLoop.plan !== undefined && typeof config.humanInLoop.plan !== "function") {
+        throw new Error(`${label} '${config.name}': humanInLoop.plan must be a function`);
+    }
 }
 export function mergeHumanInLoopFromGroup(groupHumanInLoop, childHumanInLoop) {
     if (childHumanInLoop !== undefined) {

package/dist/human-in-loop/gate.js

@@ -2,6 +2,7 @@ import { enqueueApproval, ensureApprovalList } from "./approval-tasks.js";
 import { defaultProviderForPlatform } from "./default-provider.js";
 import { spawnApprovalRunner } from "./spawn.js";
 import { ApprovalDeclinedError } from "./types.js";
+import { assertApprovalPlanHash, createApprovalPlan, formatApprovalMessage } from "./plan-hash.js";
 const providersByRuntime = new WeakMap();
 let providerWithoutRuntime;
 export function resolveProvider(runtimeOptions) {
@@ -24,10 +25,17 @@ export async function invokeWithHumanInLoop(node, ctx, runtimeOptions, commandPa
     if (!node.humanInLoop) {
         return node.handler(ctx);
     }
-    const message = node.humanInLoop.message({
+    const planContext = {
         params: ctx.params,
         commandPath
-    });
+    };
+    const baseMessage = node.humanInLoop.message(planContext);
+    const approvalPlan = node.humanInLoop.plan === undefined
+        ? undefined
+        : createApprovalPlan(await node.humanInLoop.plan(planContext));
+    const message = approvalPlan === undefined
+        ? baseMessage
+        : formatApprovalMessage(baseMessage, approvalPlan);
     if (node.humanInLoop.mode === "async") {
         const { tasks } = await ensureApprovalList(runtimeOptions);
         const { approvalId, pending } = await (options.enqueueApproval ?? enqueueApproval)({
@@ -36,6 +44,8 @@ export async function invokeWithHumanInLoop(node, ctx, runtimeOptions, commandPa
                 commandPath,
                 params: ctx.params,
                 message,
+                plan: approvalPlan?.value,
+                planHash: approvalPlan?.hash,
                 declineInputPrompt: node.humanInLoop.declineInputPrompt
             }
         });
@@ -55,5 +65,9 @@ export async function invokeWithHumanInLoop(node, ctx, runtimeOptions, commandPa
             commandPath
         });
     }
+    if (approvalPlan !== undefined && node.humanInLoop.plan !== undefined) {
+        const executionPlan = createApprovalPlan(await node.humanInLoop.plan(planContext));
+        assertApprovalPlanHash(approvalPlan.hash, executionPlan.hash);
+    }
     return node.handler(ctx);
 }

package/dist/human-in-loop/plan-hash.d.ts

@@ -0,0 +1,13 @@
+export type ApprovalPlanValue = null | boolean | number | string | ApprovalPlanValue[] | {
+    [key: string]: ApprovalPlanValue;
+};
+export interface ApprovalPlan {
+    value: ApprovalPlanValue;
+    canonical: string;
+    display: string;
+    hash: string;
+}
+export declare function isApprovalPlanValue(value: unknown): value is ApprovalPlanValue;
+export declare function createApprovalPlan(value: unknown): ApprovalPlan;
+export declare function formatApprovalMessage(message: string, plan: ApprovalPlan): string;
+export declare function assertApprovalPlanHash(expectedHash: string, actualHash: string): void;

package/dist/human-in-loop/plan-hash.js

@@ -0,0 +1,73 @@
+import { createHash } from "node:crypto";
+import { UserError } from "../user-error.js";
+export function isApprovalPlanValue(value) {
+    if (value === null || typeof value === "string" || typeof value === "boolean") {
+        return true;
+    }
+    if (typeof value === "number") {
+        return Number.isFinite(value);
+    }
+    if (Array.isArray(value)) {
+        return value.every(isApprovalPlanValue);
+    }
+    if (typeof value !== "object") {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return ((prototype === Object.prototype || prototype === null) &&
+        Object.values(value).every(isApprovalPlanValue));
+}
+function normalizePlan(value, seen) {
+    if (value === null || typeof value === "string" || typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw new UserError("Approval plan numbers must be finite.");
+        }
+        return value;
+    }
+    if (typeof value !== "object") {
+        throw new UserError("Approval plan must contain only JSON values.");
+    }
+    if (seen.has(value)) {
+        throw new UserError("Approval plan must not contain circular references.");
+    }
+    seen.add(value);
+    try {
+        if (Array.isArray(value)) {
+            return value.map((item) => normalizePlan(item, seen));
+        }
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null) {
+            throw new UserError("Approval plan must contain only JSON values.");
+        }
+        const normalized = {};
+        for (const key of Object.keys(value).sort()) {
+            normalized[key] = normalizePlan(value[key], seen);
+        }
+        return normalized;
+    }
+    finally {
+        seen.delete(value);
+    }
+}
+export function createApprovalPlan(value) {
+    const normalized = normalizePlan(value, new Set());
+    const canonical = JSON.stringify(normalized);
+    const digest = createHash("sha256").update(canonical).digest("hex");
+    return {
+        value: normalized,
+        canonical,
+        display: JSON.stringify(normalized, null, 2),
+        hash: `sha256:${digest}`
+    };
+}
+export function formatApprovalMessage(message, plan) {
+    return `${message}\n\nPlan:\n${plan.display}\n\nPlan hash: ${plan.hash}`;
+}
+export function assertApprovalPlanHash(expectedHash, actualHash) {
+    if (expectedHash !== actualHash) {
+        throw new UserError(`Approval plan changed after approval. Expected ${expectedHash}, received ${actualHash}.`);
+    }
+}

package/dist/human-in-loop/runner.js

@@ -4,6 +4,7 @@ import { createEnv, createFs } from "../runtime/io.js";
 import { ensureApprovalList } from "./approval-tasks.js";
 import { resolveProvider } from "./gate.js";
 import { createRuntimeLogger } from "../runtime-logging.js";
+import { assertApprovalPlanHash, createApprovalPlan, formatApprovalMessage, isApprovalPlanValue } from "./plan-hash.js";
 const MAX_AVAILABLE_COMMAND_PATHS = 20;
 export async function runApproval(approvalId, runtimeOptions, root) {
     const { tasks } = await ensureApprovalList(runtimeOptions);
@@ -27,6 +28,7 @@ export async function runApproval(approvalId, runtimeOptions, root) {
         throw error;
     }
     try {
+        verifyStoredApprovalPlan(approval);
         const approvalResult = await provider.requestApproval({
             message: approval.message,
             declineInputPrompt: approval.declineInputPrompt ?? undefined
@@ -50,10 +52,32 @@ export async function runApproval(approvalId, runtimeOptions, root) {
         });
         return;
     }
+    let command;
+    let ctx;
+    try {
+        command = findCommand(root, approval.commandPath);
+        ctx = createHandlerContext(command, approval.params);
+        if (approval.planHash !== undefined) {
+            if (command.humanInLoop?.plan === undefined) {
+                throw new UserError("Approval plan can no longer be verified by this command.");
+            }
+            const executionPlan = createApprovalPlan(await command.humanInLoop.plan({
+                params: approval.params,
+                commandPath: approval.commandPath
+            }));
+            assertApprovalPlanHash(approval.planHash, executionPlan.hash);
+        }
+    }
+    catch (error) {
+        await tasks.fire(approvalId, "fail", {
+            metadataPatch: {
+                error: errorMetadataFromUnknown(error)
+            }
+        });
+        return;
+    }
     await tasks.fire(approvalId, "start");
     try {
-        const command = findCommand(root, approval.commandPath);
-        const ctx = createHandlerContext(command, approval.params);
         const result = await command.handler(ctx);
         const serializedResult = serializeJsonResult(result);
         if (!serializedResult.ok) {
@@ -80,6 +104,21 @@ export async function runApproval(approvalId, runtimeOptions, root) {
         });
     }
 }
+function verifyStoredApprovalPlan(approval) {
+    const hasPlan = approval.plan !== undefined;
+    const hasPlanHash = approval.planHash !== undefined;
+    if (!hasPlan && !hasPlanHash) {
+        return;
+    }
+    if (approval.plan === undefined || approval.planHash === undefined) {
+        throw new UserError("Malformed approval plan metadata.");
+    }
+    const storedPlan = createApprovalPlan(approval.plan);
+    assertApprovalPlanHash(approval.planHash, storedPlan.hash);
+    if (!approval.message.endsWith(formatApprovalMessage("", storedPlan))) {
+        throw new UserError("Approval prompt does not match its stored plan hash.");
+    }
+}
 function readApprovalPayload(task) {
     const metadata = task.metadata;
     if (typeof metadata !== "object" || metadata === null) {
@@ -103,6 +142,8 @@ function readApprovalPayload(task) {
         params: metadata.params,
         message: metadata.message,
         declineInputPrompt,
+        plan: isApprovalPlanValue(metadata.plan) ? metadata.plan : undefined,
+        planHash: typeof metadata.planHash === "string" ? metadata.planHash : undefined,
         enqueuedAt: typeof metadata.enqueuedAt === "string" ? metadata.enqueuedAt : undefined,
         pid: typeof metadata.pid === "number" || metadata.pid === null ? metadata.pid : undefined,
         result: metadata.result,

package/dist/human-in-loop/types.d.ts

@@ -8,6 +8,10 @@ export interface HumanInLoopConfig<TParamsSchema extends ObjectSchema<any>> {
         params: Static<TParamsSchema>;
         commandPath: string;
     }) => string;
+    plan?: (ctx: {
+        params: Static<TParamsSchema>;
+        commandPath: string;
+    }) => unknown | Promise<unknown>;
     declineInputPrompt?: string;
 }
 export interface HumanInLoopRuntimeOptions {
@@ -27,6 +31,7 @@ export interface HumanInLoopPending {
     approvalId: string;
     message: string;
     enqueuedAt: string;
+    planHash?: string;
 }
 export declare class ApprovalDeclinedError extends UserError {
     readonly reason?: string;

package/dist/index.compile-check.js

@@ -1,5 +1,6 @@
 import { S } from "toolcraft-schema";
 import { defineCommand, defineGroup } from "./index.js";
+import { createFileChangeRenderers } from "./file-change-renderer.js";
 const ignoredScope = ["cli", "sdk"];
 const ignoredSecrets = {
     apiKey: { env: "API_KEY" },
@@ -29,6 +30,14 @@ const ignoredCommand = defineCommand({
         };
     },
 });
+const ignoredFileChangeCommand = defineCommand({
+    name: "status",
+    params: S.Object({}),
+    render: createFileChangeRenderers({ mode: "status" }),
+    handler: async () => ({
+        changes: [{ kind: "added", path: "flows/morning.json", newContent: "{}\n" }]
+    })
+});
 const ignoredGroup = defineGroup({
     name: "root",
     scope: ignoredScope,

package/dist/index.d.ts

@@ -208,6 +208,8 @@ export { ApprovalDeclinedError, ToolcraftBugError, UserError };
 export { createRuntimeLogger, isLogLevel, shouldEmitDiagnostic } from "./runtime-logging.js";
 export { findPackageMetadata, packageMetadata } from "./package-metadata.js";
 export type { PackageMetadata } from "./package-metadata.js";
+export type { FileChangeRendererOptions, FileChangeResult } from "./file-change-renderer.js";
+export type { FileChange, FileChangeDisplayMode, FileChangeKind } from "toolcraft-design";
 export type { DiagnosticLogEvent, LogLevel, RuntimeLogger, RuntimeLoggerInput } from "./runtime-logging.js";
 export type { AnySchema, ArraySchema, BooleanSchema, EnumSchema, JsonSchema, NumberSchema, ObjectSchema, OptionalSchema, Static, StringSchema } from "toolcraft-schema";
 export type { HumanInLoopConfig, HumanInLoopPending, HumanInLoopRuntimeOptions };

package/node_modules/toolcraft-design/dist/components/file-changes.d.ts

@@ -0,0 +1,16 @@
+export type FileChangeKind = "added" | "modified" | "deleted" | "renamed";
+export type FileChangeDisplayMode = "status" | "diff";
+export type FileChangeOutputFormat = "terminal" | "markdown";
+export interface FileChange {
+    path: string;
+    kind: FileChangeKind;
+    oldPath?: string;
+    conflict?: boolean;
+    oldContent?: string;
+    newContent?: string;
+}
+export interface RenderFileChangesOptions {
+    mode?: FileChangeDisplayMode;
+    format?: FileChangeOutputFormat;
+}
+export declare function renderFileChanges(changes: readonly FileChange[], options?: RenderFileChangesOptions): string;

package/node_modules/toolcraft-design/dist/components/file-changes.js

@@ -0,0 +1,162 @@
+import { color } from "./color.js";
+const STATUS_MARKERS = {
+    added: "A",
+    modified: "M",
+    deleted: "D",
+    renamed: "R"
+};
+const STATUS_LABELS = {
+    added: "added",
+    modified: "modified",
+    deleted: "deleted",
+    renamed: "renamed"
+};
+function changePath(change) {
+    if (change.kind === "renamed" && change.oldPath) {
+        return `${change.oldPath} -> ${change.path}`;
+    }
+    return change.path;
+}
+function colorStatusMarker(change, marker) {
+    if (change.conflict) {
+        return color.red.bold(marker);
+    }
+    switch (change.kind) {
+        case "added":
+            return color.green(marker);
+        case "modified":
+            return color.yellow(marker);
+        case "deleted":
+            return color.red(marker);
+        case "renamed":
+            return color.cyan(marker);
+    }
+}
+function formatSummary(changes) {
+    const counts = new Map();
+    let conflicts = 0;
+    for (const change of changes) {
+        counts.set(change.kind, (counts.get(change.kind) ?? 0) + 1);
+        if (change.conflict) {
+            conflicts += 1;
+        }
+    }
+    const details = Object.keys(STATUS_LABELS)
+        .flatMap((kind) => {
+        const count = counts.get(kind) ?? 0;
+        return count > 0 ? [`${count} ${STATUS_LABELS[kind]}`] : [];
+    });
+    if (conflicts > 0) {
+        details.push(`${conflicts} ${conflicts === 1 ? "conflict" : "conflicts"}`);
+    }
+    return `${changes.length} ${changes.length === 1 ? "change" : "changes"} (${details.join(", ")})`;
+}
+function renderStatus(changes, format) {
+    const lines = changes.map((change) => {
+        const marker = `${STATUS_MARKERS[change.kind]}${change.conflict ? "!" : " "}`;
+        const renderedMarker = format === "terminal" ? colorStatusMarker(change, marker) : marker;
+        return `${renderedMarker} ${changePath(change)}`;
+    });
+    const output = [...lines, "", formatSummary(changes)].join("\n");
+    return format === "markdown" ? `\`\`\`text\n${output}\n\`\`\`` : output;
+}
+function diffPath(prefix, path) {
+    return `${prefix}/${path}`;
+}
+function contentLines(content) {
+    const lines = content.split("\n");
+    if (lines.at(-1) === "") {
+        lines.pop();
+    }
+    return lines;
+}
+function commonPrefixLength(oldLines, newLines) {
+    const limit = Math.min(oldLines.length, newLines.length);
+    let index = 0;
+    while (index < limit && oldLines[index] === newLines[index]) {
+        index += 1;
+    }
+    return index;
+}
+function commonSuffixLength(oldLines, newLines, prefixLength) {
+    const limit = Math.min(oldLines.length, newLines.length) - prefixLength;
+    let length = 0;
+    while (length < limit &&
+        oldLines[oldLines.length - length - 1] === newLines[newLines.length - length - 1]) {
+        length += 1;
+    }
+    return length;
+}
+function hunkRange(startIndex, count) {
+    const lineNumber = count === 0 ? 0 : startIndex + 1;
+    return `${lineNumber},${count}`;
+}
+function createUnifiedHunk(oldContent, newContent) {
+    const oldLines = contentLines(oldContent);
+    const newLines = contentLines(newContent);
+    const prefixLength = commonPrefixLength(oldLines, newLines);
+    const suffixLength = commonSuffixLength(oldLines, newLines, prefixLength);
+    const context = 3;
+    const oldChangeEnd = oldLines.length - suffixLength;
+    const newChangeEnd = newLines.length - suffixLength;
+    const oldStart = Math.max(0, prefixLength - context);
+    const newStart = Math.max(0, prefixLength - context);
+    const oldEnd = Math.min(oldLines.length, oldChangeEnd + context);
+    const newEnd = Math.min(newLines.length, newChangeEnd + context);
+    const oldCount = oldEnd - oldStart;
+    const newCount = newEnd - newStart;
+    const before = oldLines.slice(oldStart, prefixLength).map((line) => ` ${line}`);
+    const removed = oldLines.slice(prefixLength, oldChangeEnd).map((line) => `-${line}`);
+    const added = newLines.slice(prefixLength, newChangeEnd).map((line) => `+${line}`);
+    const after = oldLines.slice(oldChangeEnd, oldEnd).map((line) => ` ${line}`);
+    return [
+        `@@ -${hunkRange(oldStart, oldCount)} +${hunkRange(newStart, newCount)} @@`,
+        ...before,
+        ...removed,
+        ...added,
+        ...after
+    ].join("\n");
+}
+function createChangePatch(change) {
+    const oldPath = change.kind === "added"
+        ? "/dev/null"
+        : diffPath("a", change.oldPath ?? change.path);
+    const newPath = change.kind === "deleted" ? "/dev/null" : diffPath("b", change.path);
+    const oldContent = change.kind === "added" ? "" : (change.oldContent ?? "");
+    const newContent = change.kind === "deleted" ? "" : (change.newContent ?? "");
+    const headers = [`--- ${oldPath}`, `+++ ${newPath}`];
+    if (oldContent !== newContent) {
+        return [...headers, createUnifiedHunk(oldContent, newContent)].join("\n");
+    }
+    return headers.join("\n");
+}
+function colorDiffLine(line) {
+    if (line.startsWith("@@")) {
+        return color.cyan(line);
+    }
+    if (line.startsWith("+++") || line.startsWith("---")) {
+        return color.bold(line);
+    }
+    if (line.startsWith("+")) {
+        return color.green(line);
+    }
+    if (line.startsWith("-")) {
+        return color.red(line);
+    }
+    return line;
+}
+function renderDiff(changes, format) {
+    const output = changes.map(createChangePatch).join("\n\n");
+    if (format === "markdown") {
+        return `\`\`\`diff\n${output}\n\`\`\``;
+    }
+    return output.split("\n").map(colorDiffLine).join("\n");
+}
+export function renderFileChanges(changes, options = {}) {
+    if (changes.length === 0) {
+        return "No file changes.";
+    }
+    const mode = options.mode ?? "status";
+    const format = options.format ?? "terminal";
+    return mode === "diff" ? renderDiff(changes, format) : renderStatus(changes, format);
+}

package/node_modules/toolcraft-design/dist/components/index.d.ts

@@ -10,6 +10,8 @@ export { formatCommandNotFound } from "./command-errors.js";
 export { formatCommandNotFoundPanel } from "./command-errors.js";
 export { renderTable } from "./table.js";
 export type { TableColumn, RenderTableOptions } from "./table.js";
+export { renderFileChanges } from "./file-changes.js";
+export type { FileChange, FileChangeDisplayMode, FileChangeKind, FileChangeOutputFormat, RenderFileChangesOptions } from "./file-changes.js";
 export { renderCatalog } from "./catalog.js";
 export type { CatalogGroup, CatalogItem, CatalogMetric, CatalogTone, RenderCatalogOptions } from "./catalog.js";
 export { getTemplatePartialNames, renderTemplate, resolveTemplatePartials } from "./template.js";

package/node_modules/toolcraft-design/dist/components/index.js

@@ -6,5 +6,6 @@ export { helpFormatter, formatColumns, formatCommand, formatUsage, formatOption,
 export { formatCommandNotFound } from "./command-errors.js";
 export { formatCommandNotFoundPanel } from "./command-errors.js";
 export { renderTable } from "./table.js";
+export { renderFileChanges } from "./file-changes.js";
 export { renderCatalog } from "./catalog.js";
 export { getTemplatePartialNames, renderTemplate, resolveTemplatePartials } from "./template.js";

package/node_modules/toolcraft-design/dist/index.d.ts

@@ -19,6 +19,8 @@ export { formatCommandNotFound } from "./components/command-errors.js";
 export { formatCommandNotFoundPanel } from "./components/command-errors.js";
 export { renderTable } from "./components/table.js";
 export type { TableColumn, RenderTableOptions } from "./components/table.js";
+export { renderFileChanges } from "./components/file-changes.js";
+export type { FileChange, FileChangeDisplayMode, FileChangeKind, FileChangeOutputFormat, RenderFileChangesOptions } from "./components/file-changes.js";
 export { renderCatalog } from "./components/catalog.js";
 export type { CatalogGroup, CatalogItem, CatalogMetric, CatalogTone, RenderCatalogOptions } from "./components/catalog.js";
 export { renderDetailCard } from "./components/detail-card.js";

package/node_modules/toolcraft-design/dist/index.js

@@ -15,6 +15,7 @@ export * as helpFormatterPlain from "./components/help-formatter-plain.js";
 export { formatCommandNotFound } from "./components/command-errors.js";
 export { formatCommandNotFoundPanel } from "./components/command-errors.js";
 export { renderTable } from "./components/table.js";
+export { renderFileChanges } from "./components/file-changes.js";
 export { renderCatalog } from "./components/catalog.js";
 export { renderDetailCard } from "./components/detail-card.js";
 export { renderInspectorCard } from "./components/inspector-card.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft",
-  "version": "0.0.98",
+  "version": "0.0.100",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -70,6 +70,10 @@
       "types": "./dist/frontmatter.d.ts",
       "import": "./dist/frontmatter.js"
     },
+    "./file-changes": {
+      "types": "./dist/file-change-renderer.d.ts",
+      "import": "./dist/file-change-renderer.js"
+    },
     "./process-runner": {
       "types": "./dist/process-runner.d.ts",
       "import": "./dist/process-runner.js"
@@ -100,7 +104,7 @@
     "postpack": "node ../../scripts/manage-bundled-workspace-deps.mjs cleanup . toolcraft-design @poe-code/frontmatter @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/agent-defs @poe-code/config-mutations @poe-code/process-runner tiny-mcp-client auth-store"
   },
   "dependencies": {
-    "toolcraft-schema": "0.0.98",
+    "toolcraft-schema": "0.0.100",
     "commander": "^13.1.0",
     "fast-string-width": "^3.0.2",
     "fast-wrap-ansi": "^0.2.0",