@pi-unipi/utility 0.2.5 → 0.2.7

package/src/diff/wrapper.ts

@@ -0,0 +1,287 @@
+/**
+ * @pi-unipi/utility — Diff Tool Wrapper
+ *
+ * Wraps the default Pi write/edit tools with Shiki-powered diff rendering.
+ * When enabled, enhanced tools are registered that:
+ * 1. Read old content before write
+ * 2. Delegate to the original tool
+ * 3. Compute diff
+ * 4. Store diff in result.details for async rendering
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ExtensionAPI, ToolDefinition, AgentToolResult } from "@mariozechner/pi-coding-agent";
+import { readDiffSettings } from "./settings.js";
+import { parseDiff } from "./parser.js";
+import { resolveDiffColors, applyDiffPalette } from "./theme.js";
+import { renderSplit, renderUnified, termW, SPLIT_MIN_WIDTH } from "./renderer.js";
+import { detectLanguageFromPath, hlBlock, MAX_HL_CHARS } from "./highlighter.js";
+
+// ─── Types ──────────────────────────────────────────────────────────────────────
+
+/** Extended tool result with diff data */
+interface DiffToolDetails {
+  /** Old file content (null for new files) */
+  oldContent: string | null;
+  /** New file content */
+  newContent: string;
+  /** Parsed diff */
+  diff: ReturnType<typeof parseDiff>;
+  /** File path */
+  filePath: string;
+  /** Detected language */
+  language: string;
+}
+
+/** Edit operation from the edit tool */
+export interface EditOperation {
+  oldText: string;
+  newText: string;
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────────
+
+/**
+ * Normalize edit tool input to get the list of edit operations.
+ * Handles both single-edit and multi-edit parameter formats.
+ */
+export function getEditOperations(input: any): EditOperation[] {
+  if (Array.isArray(input?.edits)) {
+    return input.edits.map((e: any) => ({
+      oldText: e.oldText ?? e.old_text ?? "",
+      newText: e.newText ?? e.new_text ?? "",
+    }));
+  }
+  if (input?.oldText !== undefined || input?.old_text !== undefined) {
+    return [{
+      oldText: input.oldText ?? input.old_text ?? "",
+      newText: input.newText ?? input.new_text ?? "",
+    }];
+  }
+  return [];
+}
+
+/**
+ * Summarize edit operations into aggregate diff stats.
+ */
+export function summarizeEditOperations(operations: EditOperation[]): {
+  totalEdits: number;
+  totalAdditions: number;
+  totalDeletions: number;
+} {
+  let totalAdditions = 0;
+  let totalDeletions = 0;
+
+  for (const op of operations) {
+    const oldLines = op.oldText.split("\n");
+    const newLines = op.newText.split("\n");
+    totalDeletions += oldLines.length;
+    totalAdditions += newLines.length;
+  }
+
+  return {
+    totalEdits: operations.length,
+    totalAdditions,
+    totalDeletions,
+  };
+}
+
+/**
+ * Read file content safely. Returns null if file doesn't exist.
+ */
+function readFileSafe(filePath: string): string | null {
+  try {
+    if (fs.existsSync(filePath)) {
+      return fs.readFileSync(filePath, "utf-8");
+    }
+  } catch {
+    // Ignore read errors
+  }
+  return null;
+}
+
+// ─── Tool Registration ──────────────────────────────────────────────────────────
+
+/**
+ * Register the enhanced write tool that wraps the default with diff rendering.
+ */
+export function registerEnhancedWriteTool(pi: ExtensionAPI, cwd: string): void {
+  // We need to re-register a tool with the same name "write" to override it.
+  // The approach: register our own tool that reads old content, writes the file,
+  // computes the diff, and stores it for rendering.
+
+  pi.registerTool({
+    name: "write",
+    label: "Write File",
+    description: "Write content to a file at the given path. Creates parent directories if needed. Shows a syntax-highlighted diff of the changes.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path to the file to write" },
+        content: { type: "string", description: "Content to write to the file" },
+      },
+      required: ["path", "content"],
+    } as any,
+    async execute(toolCallId: string, params: any, signal: any, _onUpdate: any, _ctx: any): Promise<any> {
+      const { path: filePath, content } = params;
+      const absolutePath = path.resolve(cwd, filePath);
+      const dir = path.dirname(absolutePath);
+
+      // Read old content before write
+      const oldContent = readFileSafe(absolutePath);
+
+      // Write the file
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(absolutePath, content, "utf-8");
+
+      // Compute diff
+      const language = detectLanguageFromPath(filePath);
+      const diff = parseDiff(oldContent ?? "", content, 3, filePath, filePath);
+
+      return {
+        content: [
+          { type: "text", text: `Successfully wrote ${content.length} bytes to ${filePath}` },
+        ],
+        details: {
+          oldContent,
+          newContent: content,
+          diff,
+          filePath,
+          language,
+        } as DiffToolDetails,
+      };
+    },
+    renderResult(result: any, _options: any, theme: any): any {
+      const details = result?.details as DiffToolDetails | undefined;
+      if (!details || !details.diff || !details.diff.lines || details.diff.lines.length === 0) {
+        return null as any;
+      }
+
+      try {
+        const dc = resolveDiffColors(theme);
+        const tw = termW();
+        const max = 60;
+
+        const rendered: string = tw >= SPLIT_MIN_WIDTH
+          ? renderSplit(details.diff, details.language, max, dc)
+          : renderUnified(details.diff, details.language, max, dc);
+
+        // Return a simple component-like object with text
+        return {
+          setText: () => {},
+          text: rendered,
+          render: () => rendered.split("\n"),
+        } as any;
+      } catch {
+        return null as any;
+      }
+    },
+  });
+}
+
+/**
+ * Register the enhanced edit tool that wraps the default with diff rendering.
+ */
+export function registerEnhancedEditTool(pi: ExtensionAPI, cwd: string): void {
+  pi.registerTool({
+    name: "edit",
+    label: "Edit File",
+    description: "Edit a file by replacing text. Shows a syntax-highlighted diff of the changes.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path to the file to edit" },
+        edits: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              oldText: { type: "string", description: "Text to replace" },
+              newText: { type: "string", description: "Replacement text" },
+            },
+            required: ["oldText", "newText"],
+          },
+          description: "Array of edit operations",
+        },
+      },
+      required: ["path", "edits"],
+    } as any,
+    async execute(toolCallId: string, params: any, signal: any, _onUpdate: any, _ctx: any): Promise<any> {
+      const { path: filePath, edits } = params;
+      const absolutePath = path.resolve(cwd, filePath);
+
+      // Read old content
+      const oldContent = readFileSafe(absolutePath);
+      if (oldContent === null) {
+        return {
+          content: [{ type: "text", text: `Error: File not found: ${filePath}` }],
+          details: undefined,
+          isError: true,
+        };
+      }
+
+      // Apply edits
+      let newContent = oldContent;
+      const operations = getEditOperations(params);
+      for (const op of operations) {
+        const idx = newContent.indexOf(op.oldText);
+        if (idx === -1) {
+          return {
+            content: [{ type: "text", text: `Error: Could not find text to replace in ${filePath}` }],
+            details: undefined,
+            isError: true,
+          };
+        }
+        newContent = newContent.substring(0, idx) + op.newText + newContent.substring(idx + op.oldText.length);
+      }
+
+      // Write the modified content
+      fs.writeFileSync(absolutePath, newContent, "utf-8");
+
+      // Compute diff
+      const language = detectLanguageFromPath(filePath);
+      const diff = parseDiff(oldContent, newContent, 3, filePath, filePath);
+      const summary = summarizeEditOperations(operations);
+
+      return {
+        content: [
+          { type: "text", text: `Successfully edited ${filePath} (${summary.totalEdits} edit${summary.totalEdits !== 1 ? "s" : ""})` },
+        ],
+        details: {
+          oldContent,
+          newContent,
+          diff,
+          filePath,
+          language,
+        } as DiffToolDetails,
+      };
+    },
+    renderResult(result: any, _options: any, theme: any): any {
+      const details = result?.details as DiffToolDetails | undefined;
+      if (!details || !details.diff || !details.diff.lines || details.diff.lines.length === 0) {
+        return null as any;
+      }
+
+      try {
+        const dc = resolveDiffColors(theme);
+        const tw = termW();
+        const max = 60;
+
+        const rendered: string = tw >= SPLIT_MIN_WIDTH
+          ? renderSplit(details.diff, details.language, max, dc)
+          : renderUnified(details.diff, details.language, max, dc);
+
+        return {
+          setText: () => {},
+          text: rendered,
+          render: () => rendered.split("\n"),
+        } as any;
+      } catch {
+        return null as any;
+      }
+    },
+  });
+}

package/src/index.ts

@@ -25,6 +25,8 @@ import {
 import { registerUtilityCommands, registerNameBadgeCommands } from "./commands.js";
 import { NameBadgeState } from "./tui/name-badge-state.js";
 import { readBadgeSettings } from "./tui/badge-settings.js";
+import { readDiffSettings } from "./diff/settings.js";
+import { registerEnhancedWriteTool, registerEnhancedEditTool } from "./diff/wrapper.js";
 import { getLifecycle } from "./lifecycle/process.js";
 import { getAnalyticsCollector } from "./analytics/collector.js";
 import { registerInfoScreen } from "./info-screen.js";
@@ -38,6 +40,12 @@ const VERSION = getPackageVersion(new URL(".", import.meta.url).pathname);
 /** Whether we've seen the first user message (for auto badge generation) */
 let firstMessageSeen = false;
 
+/** Stored user text from first input, used to build conversation summary after agent responds */
+let firstUserText = "";
+
+/** Stored UI context from first input, used to show badge overlay after agent responds */
+let firstInputCtx: any = null;
+
 /** All commands registered by this module */
 const ALL_COMMANDS = [
   UTILITY_COMMANDS.CONTINUE,
@@ -50,6 +58,7 @@ const ALL_COMMANDS = [
   UTILITY_COMMANDS.BADGE_GEN,
   UTILITY_COMMANDS.BADGE_TOGGLE,
   UTILITY_COMMANDS.BADGE_SETTINGS,
+  UTILITY_COMMANDS.UTIL_SETTINGS,
 ].map((cmd) => `unipi:${cmd}`);
 
 /** All tools registered by this module */
@@ -96,6 +105,14 @@ export default function (pi: ExtensionAPI) {
     // Restore name badge if it was visible in previous session
     await nameBadgeState.restore(pi, ctx);
 
+    // Register diff-enhanced tools if enabled
+    const diffSettings = readDiffSettings();
+    if (diffSettings.enabled) {
+      const cwd = process.cwd();
+      registerEnhancedWriteTool(pi, cwd);
+      registerEnhancedEditTool(pi, cwd);
+    }
+
     // Write model cache for TUI components
     if ((ctx as any).modelRegistry) {
       const { writeModelCache } = await import("@pi-unipi/core");
@@ -106,7 +123,7 @@ export default function (pi: ExtensionAPI) {
     }
   });
 
-  // First-message hook: auto-generate session name on first user message
+  // First-message hook: capture user text for deferred badge generation
   pi.on("input", async (_event: any, ctx: any) => {
     // Only trigger on first user message
     if (firstMessageSeen) return;
@@ -120,8 +137,8 @@ export default function (pi: ExtensionAPI) {
     const sessionName = pi.getSessionName?.();
     if (sessionName) return;
 
-    // Get first message text for context
-    const messageText = typeof _event?.content === "string"
+    // Store first message text for later use in agent_end
+    firstUserText = typeof _event?.content === "string"
       ? _event.content
       : Array.isArray(_event?.content)
         ? _event.content
@@ -130,16 +147,57 @@ export default function (pi: ExtensionAPI) {
             .join(" ")
         : "";
 
-    // Emit event for subagents to spawn background agent
-    emitEvent(pi, UNIPI_EVENTS.BADGE_GENERATE_REQUEST, {
-      source: "input-hook",
-      conversationSummary: messageText.slice(0, 500),
-    });
+    // Store ctx for badge overlay show after agent responds
+    firstInputCtx = ctx;
+  });
+
+  // After agent completes first response, generate badge name with full conversation context
+  pi.on("agent_end", async (event: any, _ctx: any) => {
+    // Only act if we captured a first input and are waiting for badge generation
+    if (!firstInputCtx) return;
+    const ctx = firstInputCtx;
+    firstInputCtx = null; // consume — only trigger once
+
+    // Check if a name was already set (e.g. manually) in the meantime
+    const sessionName = pi.getSessionName?.();
+    if (sessionName) return;
 
     // Show badge overlay if UI available
     if (ctx?.hasUI && !nameBadgeState.isVisible()) {
       await nameBadgeState.show(pi, ctx);
     }
+
+    // Build conversation summary from full message history (user + assistant)
+    const messages: any[] = event?.messages ?? [];
+    const summaryParts: string[] = [];
+
+    // Include the user's first message
+    if (firstUserText) {
+      summaryParts.push(`User: ${firstUserText}`);
+    }
+
+    // Include assistant's response text
+    const assistantMsgs = messages.filter((m: any) => m.role === "assistant");
+    for (const msg of assistantMsgs) {
+      if (Array.isArray(msg.content)) {
+        const textParts = msg.content
+          .filter((c: any) => c.type === "text")
+          .map((c: any) => c.text)
+          .join(" ");
+        if (textParts) summaryParts.push(`Assistant: ${textParts}`);
+      } else if (typeof msg.content === "string" && msg.content) {
+        summaryParts.push(`Assistant: ${msg.content}`);
+      }
+    }
+
+    // Truncate to reasonable size
+    const conversationSummary = summaryParts.join("\n").slice(0, 800);
+
+    // Emit event for subagents to spawn background agent
+    emitEvent(pi, UNIPI_EVENTS.BADGE_GENERATE_REQUEST, {
+      source: "input-hook",
+      conversationSummary,
+    });
   });
 
   // Track command usage
@@ -153,6 +211,8 @@ export default function (pi: ExtensionAPI) {
   pi.on("session_shutdown", async () => {
     nameBadgeState.hide();
     firstMessageSeen = false;
+    firstUserText = "";
+    firstInputCtx = null;
     await lifecycle.shutdown("session_shutdown");
   });
 }

package/src/tui/badge-settings.ts

@@ -1,78 +1,37 @@
 /**
  * @pi-unipi/utility — Badge Settings Manager
  *
- * Manages badge configuration stored in .unipi/config/badge.json.
- * Settings: autoGen, badgeEnabled, agentTool
+ * Thin wrappers over the unified settings manager (util-settings.json).
+ * Existing callers continue to work unchanged.
  */
 
-import * as fs from "node:fs";
-import * as path from "node:path";
+import {
+  readUtilSettings,
+  writeUtilSettings,
+  type BadgeSettingsSection,
+} from "../diff/settings.js";
 
-/** Badge settings interface */
-export interface BadgeSettings {
-  /** Auto-generate session name on first user message */
-  autoGen: boolean;
-  /** Show the badge overlay */
-  badgeEnabled: boolean;
-  /** Enable the set_session_name tool for agents */
-  agentTool: boolean;
-  /** Model to use for badge name generation. "inherit" = parent model, or "provider/model-id" */
-  generationModel: string;
-}
-
-/** Default badge settings */
-const DEFAULT_SETTINGS: BadgeSettings = {
-  autoGen: true,
-  badgeEnabled: true,
-  agentTool: true,
-  generationModel: "inherit",
-};
-
-/** Badge settings file name */
-const BADGE_CONFIG_FILE = ".unipi/config/badge.json";
+/** Badge settings interface (re-exports BadgeSettingsSection for backward compat) */
+export type BadgeSettings = BadgeSettingsSection;
 
-/**
- * Get the config file path relative to cwd.
- */
-function getConfigPath(): string {
-  return path.resolve(process.cwd(), BADGE_CONFIG_FILE);
-}
+/** Default badge settings for formatBadgeSettings display */
+const BADGE_CONFIG_FILE = ".unipi/config/util-settings.json";
 
 /**
- * Read badge settings from disk.
+ * Read badge settings from unified config.
  * Returns defaults if file doesn't exist or is malformed.
  */
 export function readBadgeSettings(): BadgeSettings {
-  try {
-    const configPath = getConfigPath();
-    if (!fs.existsSync(configPath)) return { ...DEFAULT_SETTINGS };
-    const parsed = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-    return {
-      autoGen: typeof parsed.autoGen === "boolean" ? parsed.autoGen : DEFAULT_SETTINGS.autoGen,
-      badgeEnabled: typeof parsed.badgeEnabled === "boolean" ? parsed.badgeEnabled : DEFAULT_SETTINGS.badgeEnabled,
-      agentTool: typeof parsed.agentTool === "boolean" ? parsed.agentTool : DEFAULT_SETTINGS.agentTool,
-      generationModel: typeof parsed.generationModel === "string" ? parsed.generationModel : DEFAULT_SETTINGS.generationModel,
-    };
-  } catch {
-    return { ...DEFAULT_SETTINGS };
-  }
+  return readUtilSettings().badge;
 }
 
 /**
- * Write badge settings to disk.
- * Creates .unipi/config/ directory if needed.
+ * Write badge settings to unified config.
  */
 export function writeBadgeSettings(settings: BadgeSettings): void {
-  try {
-    const configPath = getConfigPath();
-    const dir = path.dirname(configPath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    fs.writeFileSync(configPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
-  } catch {
-    // Best effort
-  }
+  const util = readUtilSettings();
+  util.badge = settings;
+  writeUtilSettings(util);
 }
 
 /**