pi-ui-extend 0.1.1

package/dist/app/workspace-actions-controller.js

@@ -0,0 +1,215 @@
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { copyTextToClipboard } from "./clipboard.js";
+import { isRecord } from "./guards.js";
+import { createId } from "./id.js";
+import { loadWorkspaceUndoIndex, prepareWorkspaceMutation, revertWorkspaceMutations, saveWorkspaceUndoIndex, workspaceMutationFromToolExecution, workspaceUndoIndexKey, } from "./workspace-undo.js";
+export class AppWorkspaceActionsController {
+    host;
+    workspaceUndoIndex = loadWorkspaceUndoIndex(getAgentDir());
+    constructor(host) {
+        this.host = host;
+    }
+    prepareWorkspaceMutation(toolName, args) {
+        const runtime = this.host.runtime();
+        return runtime ? prepareWorkspaceMutation(runtime.cwd, toolName, args) : undefined;
+    }
+    workspaceMutationFromToolExecution(input) {
+        const runtime = this.host.runtime();
+        return runtime ? workspaceMutationFromToolExecution({ cwd: runtime.cwd, ...input }) : undefined;
+    }
+    recordWorkspaceMutationForUserEntry(entryId, mutation) {
+        const entry = this.host.findUserEntry(entryId);
+        if (!entry)
+            return;
+        entry.workspaceMutations = [...(entry.workspaceMutations ?? []), mutation];
+        const sessionEntryId = this.resolveUserSessionEntryId(entry);
+        if (sessionEntryId)
+            this.persistWorkspaceMutations(sessionEntryId, entry.workspaceMutations);
+        this.host.touchEntry(entry);
+    }
+    scheduleUserSessionEntryMetadataSync() {
+        const timer = setTimeout(() => {
+            this.syncUserSessionEntryMetadata();
+            if (this.host.isRunning())
+                this.host.render();
+        }, 0);
+        timer.unref?.();
+    }
+    syncUserSessionEntryMetadata() {
+        const runtime = this.host.runtime();
+        if (!runtime)
+            return;
+        const branchUserEntries = runtime.session.sessionManager.getBranch().flatMap((sessionEntry) => {
+            if (sessionEntry.type !== "message")
+                return [];
+            if (!isRecord(sessionEntry.message) || sessionEntry.message.role !== "user")
+                return [];
+            return [{ entryId: sessionEntry.id }];
+        });
+        if (branchUserEntries.length === 0)
+            return;
+        let branchIndex = 0;
+        for (const entry of this.host.entries) {
+            if (entry.kind !== "user")
+                continue;
+            const sessionEntry = branchUserEntries[branchIndex];
+            branchIndex += 1;
+            if (!sessionEntry)
+                break;
+            let changed = false;
+            if (entry.sessionEntryId !== sessionEntry.entryId) {
+                entry.sessionEntryId = sessionEntry.entryId;
+                changed = true;
+            }
+            const hasPersistedMutations = this.hasWorkspaceMutationsForSessionEntry(sessionEntry.entryId);
+            const persistedMutations = this.workspaceMutationsForSessionEntry(sessionEntry.entryId);
+            if (!entry.workspaceMutations && hasPersistedMutations) {
+                entry.workspaceMutations = persistedMutations;
+                changed = true;
+            }
+            if (entry.workspaceMutations && (!hasPersistedMutations || !sameWorkspaceMutations(persistedMutations, entry.workspaceMutations))) {
+                this.persistWorkspaceMutations(sessionEntry.entryId, entry.workspaceMutations);
+            }
+            if (changed)
+                this.host.touchEntry(entry);
+        }
+    }
+    copyUserMessage(entryId) {
+        const entry = this.host.findUserEntry(entryId);
+        if (!entry)
+            throw new Error("User message is no longer available");
+        copyTextToClipboard(entry.text);
+        this.host.showToast("Message copied", "success");
+        this.host.setSessionStatus(this.host.runtime()?.session);
+    }
+    async forkFromUserMessage(entryId) {
+        const runtime = this.getIdleRuntimeForAction("fork");
+        if (!runtime)
+            return;
+        const entry = this.host.findUserEntry(entryId);
+        if (!entry)
+            throw new Error("User message is no longer available");
+        const sessionEntryId = this.resolveUserSessionEntryId(entry);
+        if (!sessionEntryId)
+            throw new Error("Session entry for this message is not available yet");
+        this.host.setStatus("forking session");
+        this.host.render();
+        const result = await runtime.fork(sessionEntryId);
+        if (result.cancelled) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: "Fork cancelled." });
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        this.host.resetSessionView();
+        this.host.loadSessionHistory();
+        if (result.selectedText)
+            this.host.setInput(result.selectedText);
+        this.host.addEntry({ id: createId("system"), kind: "system", text: `Forked from entry ${sessionEntryId}.` });
+        this.host.setSessionStatus(runtime.session);
+        this.host.showToast("Session forked", "success");
+    }
+    async undoChangesFromUserMessage(entryId) {
+        const runtime = this.getIdleRuntimeForAction("undo changes");
+        if (!runtime)
+            return;
+        const entry = this.host.findUserEntry(entryId);
+        if (!entry)
+            throw new Error("User message is no longer available");
+        const sessionEntryId = this.resolveUserSessionEntryId(entry);
+        if (!sessionEntryId)
+            throw new Error("Session entry for this message is not available yet");
+        const hasMutationLog = entry.workspaceMutations !== undefined || this.hasWorkspaceMutationsForSessionEntry(sessionEntryId);
+        const mutations = entry.workspaceMutations ?? this.workspaceMutationsForSessionEntry(sessionEntryId);
+        if (!hasMutationLog) {
+            throw new Error("No workspace mutation log was captured for this message. Undo is available for messages sent after this build.");
+        }
+        if (mutations.length > 0) {
+            this.host.setStatus("reverting recorded commands");
+            this.host.render();
+        }
+        const reverted = mutations.length === 0 ? { ok: true, changedFiles: 0, revertedChanges: 0 } : revertWorkspaceMutations(runtime.cwd, mutations);
+        if (!reverted.ok)
+            throw new Error(reverted.error);
+        this.host.setStatus("truncating session");
+        this.host.render();
+        const result = await runtime.session.navigateTree(sessionEntryId);
+        if (result.aborted) {
+            this.host.showToast("Undo cancelled", "info");
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        if (result.cancelled) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: "Undo cancelled." });
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        this.host.resetSessionView();
+        this.host.loadSessionHistory();
+        if (result.editorText && !this.host.getInput().trim())
+            this.host.setInput(result.editorText);
+        this.host.addEntry({
+            id: createId("system"),
+            kind: "system",
+            text: `Undid changes from entry ${sessionEntryId}. Reverted ${reverted.revertedChanges} command${reverted.revertedChanges === 1 ? "" : "s"} across ${reverted.changedFiles} file${reverted.changedFiles === 1 ? "" : "s"}.`,
+        });
+        this.host.setSessionStatus(runtime.session);
+        this.host.showToast("Changes undone", "success");
+    }
+    resolveUserSessionEntryId(entry) {
+        if (!entry.sessionEntryId)
+            this.syncUserSessionEntryMetadata();
+        return entry.sessionEntryId;
+    }
+    getIdleRuntimeForAction(actionName) {
+        const runtime = this.host.runtime();
+        if (!runtime) {
+            this.host.addEntry({ id: createId("error"), kind: "error", text: "Runtime is not initialized" });
+            this.host.showToast(`${actionName} unavailable`, "error");
+            this.host.render();
+            return undefined;
+        }
+        if (runtime.session.isStreaming) {
+            this.host.showToast(`${actionName} is unavailable while the agent is running`, "warning");
+            this.host.render();
+            return undefined;
+        }
+        if (runtime.session.isCompacting) {
+            this.host.showToast(`${actionName} is unavailable while compacting`, "warning");
+            this.host.render();
+            return undefined;
+        }
+        return runtime;
+    }
+    workspaceMutationsForSessionEntry(entryId) {
+        const key = this.workspaceUndoIndexKey(entryId);
+        return key ? (this.workspaceUndoIndex.entries[key] ?? []) : [];
+    }
+    hasWorkspaceMutationsForSessionEntry(entryId) {
+        const key = this.workspaceUndoIndexKey(entryId);
+        return key ? Object.prototype.hasOwnProperty.call(this.workspaceUndoIndex.entries, key) : false;
+    }
+    persistWorkspaceMutations(entryId, mutations) {
+        const key = this.workspaceUndoIndexKey(entryId);
+        if (!key)
+            return;
+        const hasExisting = Object.prototype.hasOwnProperty.call(this.workspaceUndoIndex.entries, key);
+        if (hasExisting && sameWorkspaceMutations(this.workspaceUndoIndex.entries[key] ?? [], mutations))
+            return;
+        this.workspaceUndoIndex.entries[key] = [...mutations];
+        try {
+            saveWorkspaceUndoIndex(getAgentDir(), this.workspaceUndoIndex);
+        }
+        catch {
+            // Undo persistence is best-effort; in-memory undo still works for this run.
+        }
+    }
+    workspaceUndoIndexKey(entryId) {
+        const session = this.host.runtime()?.session;
+        if (!session)
+            return undefined;
+        return workspaceUndoIndexKey(session.sessionFile, session.sessionManager.getSessionId(), entryId);
+    }
+}
+function sameWorkspaceMutations(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}

package/dist/app/workspace-undo.d.ts

@@ -0,0 +1,44 @@
+export type WorkspaceUndoIndex = {
+    version: 1;
+    entries: Record<string, WorkspaceMutation[]>;
+};
+export type WorkspaceMutation = WorkspacePatchMutation | WorkspaceWriteMutation;
+export type WorkspacePatchMutation = {
+    type: "patch";
+    patch: string;
+    toolName?: string;
+};
+export type WorkspaceWriteMutation = {
+    type: "write";
+    path: string;
+    beforeContent?: string;
+    afterContent: string;
+    toolName?: string;
+};
+export type WorkspaceMutationPreparation = {
+    type: "write";
+    path: string;
+    beforeContent?: string;
+};
+export type WorkspaceMutationFromToolInput = {
+    cwd: string;
+    toolName: string;
+    args: unknown;
+    details: unknown;
+    isError: boolean;
+    preparation?: WorkspaceMutationPreparation | undefined;
+};
+export type WorkspaceRevertResult = {
+    ok: true;
+    changedFiles: number;
+    revertedChanges: number;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function workspaceUndoIndexKey(_sessionFile: string | undefined, _sessionId: string, entryId: string): string;
+export declare function loadWorkspaceUndoIndex(agentDir: string): WorkspaceUndoIndex;
+export declare function saveWorkspaceUndoIndex(agentDir: string, index: WorkspaceUndoIndex): void;
+export declare function prepareWorkspaceMutation(cwd: string, toolName: string, args: unknown): WorkspaceMutationPreparation | undefined;
+export declare function workspaceMutationFromToolExecution(input: WorkspaceMutationFromToolInput): WorkspaceMutation | undefined;
+export declare function revertWorkspaceMutations(cwd: string, mutations: readonly WorkspaceMutation[]): WorkspaceRevertResult;

package/dist/app/workspace-undo.js

@@ -0,0 +1,215 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+const UNDO_INDEX_VERSION = 1;
+export function workspaceUndoIndexKey(_sessionFile, _sessionId, entryId) {
+    return entryId;
+}
+export function loadWorkspaceUndoIndex(agentDir) {
+    try {
+        const parsed = JSON.parse(readFileSync(workspaceUndoIndexPath(agentDir), "utf8"));
+        return parseUndoIndex(parsed) ?? emptyUndoIndex();
+    }
+    catch {
+        return emptyUndoIndex();
+    }
+}
+export function saveWorkspaceUndoIndex(agentDir, index) {
+    const path = workspaceUndoIndexPath(agentDir);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(index, null, 2)}\n`, "utf8");
+}
+export function prepareWorkspaceMutation(cwd, toolName, args) {
+    const name = normalizedToolName(toolName);
+    if (name !== "write")
+        return undefined;
+    const record = plainRecord(args);
+    const rawPath = stringValue(record?.path);
+    const afterContent = stringValue(record?.content);
+    if (!rawPath || afterContent === undefined)
+        return undefined;
+    const safePath = safeRelativePath(cwd, rawPath);
+    if (!safePath)
+        return undefined;
+    const absolutePath = resolve(cwd, safePath);
+    return {
+        type: "write",
+        path: safePath,
+        ...(existsSync(absolutePath) ? { beforeContent: readFileSync(absolutePath, "utf8") } : {}),
+    };
+}
+export function workspaceMutationFromToolExecution(input) {
+    if (input.isError)
+        return undefined;
+    const name = normalizedToolName(input.toolName);
+    if (name === "write" && input.preparation?.type === "write") {
+        const record = plainRecord(input.args);
+        const afterContent = stringValue(record?.content);
+        if (afterContent === undefined || input.preparation.beforeContent === afterContent)
+            return undefined;
+        return {
+            type: "write",
+            path: input.preparation.path,
+            ...(input.preparation.beforeContent === undefined ? {} : { beforeContent: input.preparation.beforeContent }),
+            afterContent,
+            toolName: input.toolName,
+        };
+    }
+    const patch = patchFromDetails(input.details) ?? patchFromArgs(input.args);
+    if (!patch || !looksLikeUnifiedPatch(patch))
+        return undefined;
+    if (name === "edit" || name === "apply_patch" || name === "ast_apply") {
+        return { type: "patch", patch, toolName: input.toolName };
+    }
+    return undefined;
+}
+export function revertWorkspaceMutations(cwd, mutations) {
+    const changedFiles = new Set();
+    const applied = [];
+    for (const mutation of [...mutations].reverse()) {
+        const result = applyMutation(cwd, mutation, "undo");
+        if (!result.ok) {
+            const rollback = rollbackMutations(cwd, applied);
+            const rollbackText = rollback.ok ? "Rolled back already-applied undo steps." : `Rollback failed: ${rollback.error}`;
+            return { ok: false, error: `${result.error}\n${rollbackText}` };
+        }
+        for (const file of result.changedFiles)
+            changedFiles.add(file);
+        applied.push(mutation);
+    }
+    return { ok: true, changedFiles: changedFiles.size, revertedChanges: applied.length };
+}
+function rollbackMutations(cwd, appliedUndoMutations) {
+    for (const mutation of [...appliedUndoMutations].reverse()) {
+        const result = applyMutation(cwd, mutation, "redo");
+        if (!result.ok)
+            return { ok: false, error: result.error };
+    }
+    return { ok: true, changedFiles: 0, revertedChanges: appliedUndoMutations.length };
+}
+function applyMutation(cwd, mutation, direction) {
+    if (mutation.type === "patch")
+        return applyPatchMutation(cwd, mutation, direction);
+    return applyWriteMutation(cwd, mutation, direction);
+}
+function applyPatchMutation(cwd, mutation, direction) {
+    const args = ["apply", ...(direction === "undo" ? ["--reverse"] : []), "--whitespace=nowarn"];
+    const check = runGitApply(cwd, [...args, "--check"], mutation.patch);
+    if (check.status !== 0)
+        return { ok: false, error: commandError(`git ${args.join(" ")} --check`, check) };
+    const apply = runGitApply(cwd, args, mutation.patch);
+    if (apply.status !== 0)
+        return { ok: false, error: commandError(`git ${args.join(" ")}`, apply) };
+    return { ok: true, changedFiles: filesFromPatch(mutation.patch) };
+}
+function applyWriteMutation(cwd, mutation, direction) {
+    const safePath = safeRelativePath(cwd, mutation.path);
+    if (!safePath)
+        return { ok: false, error: `Refusing to modify path outside workspace: ${mutation.path}` };
+    const absolutePath = resolve(cwd, safePath);
+    const expectedContent = direction === "undo" ? mutation.afterContent : mutation.beforeContent;
+    const nextContent = direction === "undo" ? mutation.beforeContent : mutation.afterContent;
+    const currentExists = existsSync(absolutePath);
+    const currentContent = currentExists ? readFileSync(absolutePath, "utf8") : undefined;
+    if (currentContent !== expectedContent) {
+        return { ok: false, error: `Refusing to ${direction} write for ${safePath}: file content changed since the recorded command.` };
+    }
+    if (nextContent === undefined) {
+        if (currentExists)
+            rmSync(absolutePath, { force: true });
+    }
+    else {
+        mkdirSync(dirname(absolutePath), { recursive: true });
+        writeFileSync(absolutePath, nextContent, "utf8");
+    }
+    return { ok: true, changedFiles: [safePath] };
+}
+function emptyUndoIndex() {
+    return { version: UNDO_INDEX_VERSION, entries: {} };
+}
+function parseUndoIndex(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const record = value;
+    if (record.version !== UNDO_INDEX_VERSION || !isMutationRecord(record.entries))
+        return undefined;
+    return { version: UNDO_INDEX_VERSION, entries: record.entries };
+}
+function workspaceUndoIndexPath(agentDir) {
+    return join(agentDir, "pix", "workspace-undo", "index.json");
+}
+function runGitApply(cwd, args, input) {
+    return spawnSync("git", ["-c", "core.autocrlf=false", ...args], {
+        cwd,
+        input,
+        encoding: "utf8",
+        maxBuffer: 20 * 1024 * 1024,
+    });
+}
+function commandError(command, result) {
+    if (result.error)
+        return `${command} failed: ${result.error.message}`;
+    const message = result.stderr?.trim() || result.stdout?.trim() || `exit code ${result.status ?? "unknown"}`;
+    return `${command} failed: ${message}`;
+}
+function normalizedToolName(toolName) {
+    return toolName.split(/[.:/]/).filter(Boolean).at(-1)?.trim().toLowerCase() ?? toolName.toLowerCase();
+}
+function plainRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function patchFromDetails(details) {
+    const record = plainRecord(details);
+    return stringValue(record?.patch) ?? stringValue(record?.diff);
+}
+function patchFromArgs(args) {
+    const record = plainRecord(args);
+    return stringValue(record?.patch) ?? stringValue(record?.input);
+}
+function looksLikeUnifiedPatch(text) {
+    return /^---\s+/m.test(text) && /^\+\+\+\s+/m.test(text) && /^@@\s/m.test(text);
+}
+function filesFromPatch(patch) {
+    const files = new Set();
+    for (const line of patch.split("\n")) {
+        const match = /^(?:---|\+\+\+)\s+(.+?)(?:\t.*)?$/.exec(line);
+        const file = match?.[1]?.trim();
+        if (!file || file === "/dev/null")
+            continue;
+        files.add(file.replace(/^[ab]\//, ""));
+    }
+    return [...files];
+}
+function safeRelativePath(cwd, inputPath) {
+    const absolutePath = isAbsolute(inputPath) ? resolve(inputPath) : resolve(cwd, inputPath);
+    const relativePath = relative(resolve(cwd), absolutePath);
+    if (!relativePath || relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath))
+        return undefined;
+    return relativePath;
+}
+function isMutationRecord(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    return Object.values(value).every(isMutations);
+}
+function isMutations(value) {
+    return Array.isArray(value) && value.every(isMutation);
+}
+function isMutation(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const record = value;
+    if (record.type === "patch") {
+        return typeof record.patch === "string" && (record.toolName === undefined || typeof record.toolName === "string");
+    }
+    if (record.type === "write") {
+        return (typeof record.path === "string" &&
+            typeof record.afterContent === "string" &&
+            (record.beforeContent === undefined || typeof record.beforeContent === "string") &&
+            (record.toolName === undefined || typeof record.toolName === "string"));
+    }
+    return false;
+}

package/dist/config.d.ts

@@ -0,0 +1,62 @@
+import { type AppIconThemeName } from "./app/icons.js";
+export type ToolRendererRule = {
+    previewLines?: number;
+    direction?: "head" | "tail";
+    color?: string;
+    defaultExpanded?: boolean;
+    compactHidden?: boolean;
+    hidden?: boolean;
+};
+export type ResolvedToolRule = {
+    previewLines: number;
+    direction: "head" | "tail";
+    color: string;
+    defaultExpanded?: boolean;
+    compactHidden?: boolean;
+    hidden?: boolean;
+};
+export type ToolRendererConfig = {
+    default: ToolRendererRule;
+    tools: Record<string, ToolRendererRule>;
+};
+export type OutputFiltersConfig = {
+    patterns: string[];
+};
+export type PromptEnhancerConfig = {
+    modelRef: string;
+};
+export type ModelColorsConfig = {
+    rules: Record<string, string>;
+};
+export type IconThemeConfig = {
+    name: AppIconThemeName;
+};
+export type DictationLanguageModelConfig = {
+    dirName: string;
+    url: string;
+    label: string;
+};
+export type DictationConfig = {
+    languages: Record<string, DictationLanguageModelConfig>;
+    language?: string;
+};
+export type PixConfig = {
+    toolRenderer: ToolRendererConfig;
+    outputFilters: OutputFiltersConfig;
+    promptEnhancer: PromptEnhancerConfig;
+    modelColors: ModelColorsConfig;
+    iconTheme: IconThemeConfig;
+    dictation: DictationConfig;
+};
+export declare function getPixConfigPath(homeDir?: string): string;
+export declare function loadPixConfig(): PixConfig;
+export declare function savePixDictationLanguage(language: string): void;
+export declare function upsertPixDictationLanguageInJsonc(source: string, language: string): string;
+export declare function resolveModelColor(modelRef: string, config: ModelColorsConfig): string | undefined;
+export declare function compileOutputFilterPatterns(patterns: readonly string[]): RegExp[];
+export declare function stripDcpDisplayMetadata(text: string): string;
+export declare function applyOutputFilters(text: string, filters: readonly RegExp[]): string;
+export declare function outputFiltersRemoveDcpIdMetadataLine(filters: readonly RegExp[]): boolean;
+export declare function suppressPendingDcpIdMetadataLine(text: string): string;
+export declare function resolveToolRule(toolName: string, config: ToolRendererConfig): ResolvedToolRule;
+export declare function resolveColor(colorRef: string, themeColors: Record<string, string>): string;