@groeponline/pi-wishcraft 0.17.3

package/src/tools/patch.ts

@@ -0,0 +1,179 @@
+import { readFileSync, writeFileSync, copyFileSync, unlinkSync, existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getAgentPath } from "../paths/agent-dirs.ts";
+
+export interface PatchHunk {
+  oldStart: number;
+  oldLines: number;
+  newStart: number;
+  newLines: number;
+  lines: string[];
+}
+
+export interface FilePatch {
+  targetFile: string;
+  hunks: PatchHunk[];
+}
+
+export interface PatchResult {
+  success: boolean;
+  targetFile: string;
+  appliedHunks: number;
+  totalHunks: number;
+  backupPath?: string;
+  error?: string;
+}
+
+const undoStack: { targetFile: string; backupPath: string; timestamp: number }[] = [];
+const MAX_UNDO_STACK = 10;
+
+/**
+ * Parse a unified diff string into structured FilePatch objects.
+ */
+export function parseUnifiedDiff(diffText: string): FilePatch[] {
+  const patches: FilePatch[] = [];
+  const lines = diffText.split(/\r?\n/);
+  let currentPatch: FilePatch | null = null;
+  let currentHunk: PatchHunk | null = null;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    if (line.startsWith("--- ")) {
+      continue;
+    }
+
+    if (line.startsWith("+++ ")) {
+      const rawPath = line.slice(4).trim();
+      const targetFile = rawPath.replace(/^[ab]\//, "");
+      currentPatch = { targetFile, hunks: [] };
+      patches.push(currentPatch);
+      continue;
+    }
+
+    const hunkHeaderMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+    if (hunkHeaderMatch && currentPatch) {
+      currentHunk = {
+        oldStart: parseInt(hunkHeaderMatch[1], 10),
+        oldLines: parseInt(hunkHeaderMatch[2] ?? "1", 10),
+        newStart: parseInt(hunkHeaderMatch[3], 10),
+        newLines: parseInt(hunkHeaderMatch[4] ?? "1", 10),
+        lines: [],
+      };
+      currentPatch.hunks.push(currentHunk);
+      continue;
+    }
+
+    if (currentHunk && (line.startsWith("+") || line.startsWith("-") || line.startsWith(" ") || line === "")) {
+      currentHunk.lines.push(line);
+    }
+  }
+
+  return patches;
+}
+
+/**
+ * Apply a FilePatch to a file safely with an atomic backup.
+ */
+export function applyFilePatch(patch: FilePatch, baseDir: string = process.cwd()): PatchResult {
+  const fullPath = join(baseDir, patch.targetFile);
+  
+  if (!existsSync(fullPath)) {
+    return {
+      success: false,
+      targetFile: patch.targetFile,
+      appliedHunks: 0,
+      totalHunks: patch.hunks.length,
+      error: `Target file not found: ${fullPath}`,
+    };
+  }
+
+  // 1. Create backup
+  const backupDir = getAgentPath("patch-backups");
+  if (!existsSync(backupDir)) {
+    mkdirSync(backupDir, { recursive: true });
+  }
+  const backupPath = join(backupDir, `${Date.now()}-${patch.targetFile.replace(/\//g, "_")}.bak`);
+  copyFileSync(fullPath, backupPath);
+
+  try {
+    const originalContent = readFileSync(fullPath, "utf-8");
+    let fileLines = originalContent.split(/\r?\n/);
+    let appliedHunks = 0;
+
+    for (const hunk of patch.hunks) {
+      const targetLineIdx = hunk.oldStart - 1;
+      const expectedOldLines = hunk.lines.filter((l) => !l.startsWith("+"));
+      
+      // Match context check
+      let matches = true;
+      for (let j = 0; j < expectedOldLines.length; j++) {
+        const expected = expectedOldLines[j].slice(1);
+        const actual = fileLines[targetLineIdx + j];
+        if (actual !== undefined && actual !== expected) {
+          matches = false;
+          break;
+        }
+      }
+
+      if (matches) {
+        const newHunkLines: string[] = [];
+        for (const line of hunk.lines) {
+          if (!line.startsWith("-")) {
+            newHunkLines.push(line.startsWith("+") ? line.slice(1) : line.slice(1));
+          }
+        }
+        
+        fileLines.splice(targetLineIdx, hunk.oldLines, ...newHunkLines);
+        appliedHunks++;
+      }
+    }
+
+    writeFileSync(fullPath, fileLines.join("\n"), "utf-8");
+
+    // Track undo stack
+    undoStack.push({ targetFile: fullPath, backupPath, timestamp: Date.now() });
+    if (undoStack.length > MAX_UNDO_STACK) {
+      const oldest = undoStack.shift();
+      if (oldest && existsSync(oldest.backupPath)) {
+        try { unlinkSync(oldest.backupPath); } catch {}
+      }
+    }
+
+    return {
+      success: appliedHunks > 0,
+      targetFile: patch.targetFile,
+      appliedHunks,
+      totalHunks: patch.hunks.length,
+      backupPath,
+    };
+  } catch (err) {
+    // Revert from backup
+    copyFileSync(backupPath, fullPath);
+    return {
+      success: false,
+      targetFile: patch.targetFile,
+      appliedHunks: 0,
+      totalHunks: patch.hunks.length,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+/**
+ * Revert the last applied patch.
+ */
+export function undoLastPatch(): { success: boolean; targetFile?: string; error?: string } {
+  const last = undoStack.pop();
+  if (!last || !existsSync(last.backupPath)) {
+    return { success: false, error: "No undo backup available" };
+  }
+
+  try {
+    copyFileSync(last.backupPath, last.targetFile);
+    unlinkSync(last.backupPath);
+    return { success: true, targetFile: last.targetFile };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}

package/src/tools/ripgrep.ts

@@ -0,0 +1,104 @@
+import { spawnSync } from "node:child_process";
+
+export interface RipgrepMatch {
+  file: string;
+  lineNumber: number;
+  content: string;
+}
+
+export interface RipgrepOptions {
+  cwd?: string;
+  typeFilter?: string;
+  maxResults?: number;
+}
+
+export interface RipgrepResult {
+  matches: RipgrepMatch[];
+  totalCount: number;
+  engine: "ripgrep" | "grep-fallback";
+  error?: string;
+}
+
+/**
+ * Execute a ripgrep (or fallback grep) search programmatically for subagent use.
+ */
+export function searchRipgrep(pattern: string, options: RipgrepOptions = {}): RipgrepResult {
+  const cwd = options.cwd ?? process.cwd();
+  const maxResults = options.maxResults ?? 50;
+
+  // Try rg first
+  try {
+    const rgArgs = ["--json", "-m", String(maxResults), "-i"];
+    if (options.typeFilter) {
+      rgArgs.push("-t", options.typeFilter);
+    }
+    rgArgs.push(pattern, ".");
+
+    const proc = spawnSync("rg", rgArgs, { cwd, encoding: "utf-8", maxBuffer: 5 * 1024 * 1024 });
+
+    if (proc.status === 0 || proc.status === 1) {
+      const matches: RipgrepMatch[] = [];
+      const lines = (proc.stdout ?? "").split("\n");
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed.type === "match") {
+            const data = parsed.data;
+            matches.push({
+              file: data.path.text,
+              lineNumber: data.line_number,
+              content: data.lines.text.trimEnd(),
+            });
+          }
+        } catch {
+          // ignore non-json lines
+        }
+      }
+
+      return {
+        matches: matches.slice(0, maxResults),
+        totalCount: matches.length,
+        engine: "ripgrep",
+      };
+    }
+  } catch {
+    // Fallback to standard grep
+  }
+
+  // Fallback: standard grep
+  try {
+    const grepArgs = ["-rn", "-m", String(maxResults), "--exclude-dir=node_modules", "--exclude-dir=.git", pattern, "."];
+    const proc = spawnSync("grep", grepArgs, { cwd, encoding: "utf-8", maxBuffer: 5 * 1024 * 1024 });
+
+    const matches: RipgrepMatch[] = [];
+    const lines = (proc.stdout ?? "").split("\n");
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      const parts = line.split(":");
+      if (parts.length >= 3) {
+        const file = parts[0];
+        const lineNumber = parseInt(parts[1], 10);
+        const content = parts.slice(2).join(":").trimEnd();
+        if (!isNaN(lineNumber)) {
+          matches.push({ file, lineNumber, content });
+        }
+      }
+    }
+
+    return {
+      matches: matches.slice(0, maxResults),
+      totalCount: matches.length,
+      engine: "grep-fallback",
+    };
+  } catch (err) {
+    return {
+      matches: [],
+      totalCount: 0,
+      engine: "grep-fallback",
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}

package/src/usage/context.ts

@@ -0,0 +1,97 @@
+export interface CoreContextUsage {
+  contextTokens: number;
+  contextWindow: number;
+  contextPercent: number;
+}
+
+interface ContextUsageSource {
+  sessionManager: {
+    getLeafId(): string | null;
+  };
+  getContextUsage(): unknown;
+}
+
+function isContextUsageSource(value: unknown): value is ContextUsageSource {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "sessionManager" in value &&
+    "getContextUsage" in value &&
+    typeof (value as any).getContextUsage === "function" &&
+    typeof (value as any).sessionManager === "object" &&
+    (value as any).sessionManager !== null &&
+    "getLeafId" in (value as any).sessionManager &&
+    typeof (value as any).sessionManager.getLeafId === "function"
+  );
+}
+
+export class CoreContextUsageCache {
+  private _sessionManager: ContextUsageSource["sessionManager"] | null = null;
+  private _leafId: string | null = null;
+  private _usage: CoreContextUsage | null = null;
+
+  public get(ctx: unknown): CoreContextUsage | null {
+    if (!isContextUsageSource(ctx)) {
+      return readCoreContextUsage(ctx);
+    }
+    const mgr = ctx.sessionManager;
+    const leaf = mgr.getLeafId();
+    if (this._sessionManager !== mgr || this._leafId !== leaf) {
+      this._sessionManager = mgr;
+      this._leafId = leaf;
+      this._usage = readCoreContextUsage(ctx);
+    }
+    return this._usage;
+  }
+
+  public reset(): void {
+    this._sessionManager = null;
+    this._leafId = null;
+    this._usage = null;
+  }
+}
+
+export function estimateInitialContextTokens(ctx: unknown): number | null {
+  if (typeof ctx !== "object" || ctx === null || !("getSystemPrompt" in ctx)) {
+    return null;
+  }
+  const getter = (ctx as any).getSystemPrompt;
+  if (typeof getter !== "function") return null;
+
+  const prompt = getter.call(ctx);
+  if (typeof prompt !== "string" || prompt.trim() === "") {
+    return null;
+  }
+  return Math.ceil(prompt.length / 4);
+}
+
+export function readCoreContextUsage(ctx: unknown): CoreContextUsage | null {
+  if (typeof ctx !== "object" || ctx === null || !("getContextUsage" in ctx)) {
+    return null;
+  }
+  const getter = (ctx as any).getContextUsage;
+  if (typeof getter !== "function") return null;
+
+  const usage = getter.call(ctx);
+  if (typeof usage !== "object" || usage === null) {
+    return null;
+  }
+
+  const u = usage as any;
+  if (!("tokens" in u) || typeof u.tokens !== "number" || !Number.isFinite(u.tokens)) {
+    return null;
+  }
+  if (!("contextWindow" in u) || typeof u.contextWindow !== "number" || !Number.isFinite(u.contextWindow) || u.contextWindow <= 0) {
+    return null;
+  }
+
+  const pct = "percent" in u && typeof u.percent === "number" && Number.isFinite(u.percent) 
+    ? u.percent 
+    : (u.tokens / u.contextWindow) * 100;
+
+  return {
+    contextTokens: u.tokens,
+    contextWindow: u.contextWindow,
+    contextPercent: pct,
+  };
+}

package/src/usage/ledger.ts

@@ -0,0 +1,293 @@
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+
+export type SessionAssistantUsage = AssistantMessage["usage"];
+
+export interface SessionTokenStats {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  cost: number;
+  subagentCost: number;
+  lastAssistant: AssistantMessage | undefined;
+  thinkingLevelFromSession: string | null;
+}
+
+export type LedgerSnapshot = SessionTokenStats;
+
+export function hasSessionAssistantUsage(value: unknown): value is SessionAssistantUsage {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "input" in value &&
+    "output" in value &&
+    "cacheRead" in value &&
+    "cacheWrite" in value &&
+    "cost" in value &&
+    typeof (value as any).cost === "object" &&
+    "total" in (value as any).cost
+  );
+}
+
+export function isSessionAssistantMessage(value: unknown): value is AssistantMessage {
+  if (typeof value !== "object" || value === null) return false;
+  const msg = (value as any);
+  return msg.role === "assistant" && hasSessionAssistantUsage(msg.usage);
+}
+
+export function getUsageTokenTotal(usage: SessionAssistantUsage): number {
+  return usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+}
+
+const SUBAGENT_SLASH_RESULT_TYPE = "subagent-slash-result";
+function getSubagentCost(entry: any): number {
+  if (!entry || typeof entry !== "object") return 0;
+  
+  let results: unknown[] | undefined;
+  if (entry.type === "custom_message" && entry.customType === SUBAGENT_SLASH_RESULT_TYPE) {
+    const details = entry.details;
+    if (details && typeof details === "object") {
+      const result = (details as any).result;
+      if (result && typeof result === "object") {
+        const inner = (result as any).details;
+        if (inner && typeof inner === "object" && Array.isArray((inner as any).results)) {
+          results = (inner as any).results;
+        }
+      }
+    }
+  } else if (entry.type === "message" && entry.message && typeof entry.message === "object") {
+    const m = entry.message as any;
+    if (m.role === "toolResult" && m.toolName === "subagent" && m.details && typeof m.details === "object" && Array.isArray(m.details.results)) {
+      results = m.details.results;
+    }
+  }
+  
+  if (!results) return 0;
+
+  let total = 0;
+  for (const r of results) {
+    if (r && typeof r === "object" && "usage" in r) {
+      const u = (r as any).usage;
+      if (u && typeof u === "object" && typeof u.cost === "number") {
+        total += u.cost;
+      }
+    }
+  }
+  return total;
+}
+
+export class TokenLedger {
+  private _input = 0;
+  private _output = 0;
+  private _cacheRead = 0;
+  private _cacheWrite = 0;
+  private _cost = 0;
+  private _subagentCost = 0;
+  private _lastAssistant: AssistantMessage | undefined = undefined;
+  private _thinkingLevel: string | null = null;
+  private _generation = 0;
+
+  public process(event: unknown): void {
+    if (typeof event !== "object" || event === null) return;
+    const e = event as any;
+
+    let changed = false;
+
+    if (e.type === "thinking_level_change" && typeof e.thinkingLevel === "string") {
+      this._thinkingLevel = e.thinkingLevel;
+      changed = true;
+    }
+
+    const subCost = getSubagentCost(e);
+    if (subCost > 0) {
+      this._subagentCost += subCost;
+      changed = true;
+    }
+
+    if (e.type === "message" && isSessionAssistantMessage(e.message)) {
+      const m = e.message;
+      if (m.stopReason !== "error" && m.stopReason !== "aborted") {
+        this._input += m.usage.input;
+        this._output += m.usage.output;
+        this._cacheRead += m.usage.cacheRead;
+        this._cacheWrite += m.usage.cacheWrite;
+        this._cost += m.usage.cost.total;
+        if (getUsageTokenTotal(m.usage) > 0) {
+          this._lastAssistant = m;
+        }
+        changed = true;
+      }
+    }
+
+    if (changed) {
+      this._generation++;
+    }
+  }
+
+  public get generation(): number {
+    return this._generation;
+  }
+
+  public clone(): TokenLedger {
+    const copy = new TokenLedger();
+    copy._input = this._input;
+    copy._output = this._output;
+    copy._cacheRead = this._cacheRead;
+    copy._cacheWrite = this._cacheWrite;
+    copy._cost = this._cost;
+    copy._subagentCost = this._subagentCost;
+    copy._lastAssistant = this._lastAssistant;
+    copy._thinkingLevel = this._thinkingLevel;
+    copy._generation = this._generation;
+    return copy;
+  }
+
+  public snapshot(): LedgerSnapshot {
+    return {
+      input: this._input,
+      output: this._output,
+      cacheRead: this._cacheRead,
+      cacheWrite: this._cacheWrite,
+      cost: this._cost,
+      subagentCost: this._subagentCost,
+      lastAssistant: this._lastAssistant,
+      thinkingLevelFromSession: this._thinkingLevel,
+    };
+  }
+}
+
+export interface SessionBranchProvider {
+  getLeafId(): string | null;
+  getBranch(): readonly unknown[];
+}
+
+function isSessionBranchProvider(value: unknown): value is SessionBranchProvider {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "getLeafId" in value &&
+    "getBranch" in value &&
+    typeof (value as any).getLeafId === "function" &&
+    typeof (value as any).getBranch === "function"
+  );
+}
+
+export class SessionBranchCache {
+  private _provider: SessionBranchProvider | null = null;
+  private _leafId: string | null = null;
+  private _branch: readonly unknown[] = [];
+
+  get(source: unknown): readonly unknown[] {
+    if (!isSessionBranchProvider(source)) return [];
+    const leafId = source.getLeafId();
+    if (this._provider !== source || this._leafId !== leafId) {
+      this._provider = source;
+      this._leafId = leafId;
+      this._branch = source.getBranch();
+    }
+    return this._branch;
+  }
+
+  reset(): void {
+    this._provider = null;
+    this._leafId = null;
+    this._branch = [];
+  }
+}
+
+export function computeSessionTokenStats(sessionEvents: readonly unknown[]): SessionTokenStats {
+  const ledger = new TokenLedger();
+  for (const event of sessionEvents) {
+    ledger.process(event);
+  }
+  return ledger.snapshot();
+}
+
+function computeEventSignature(event: unknown): string {
+  if (typeof event !== "object" || event === null) return "nil";
+  const e = event as any;
+  if (e.type === "thinking_level_change") return `t:${e.thinkingLevel}`;
+  const subCost = getSubagentCost(e);
+  if (subCost > 0) return `s:${e.details?.results?.length}:${subCost}`;
+  if (e.type === "message" && e.message && e.message.role === "assistant") {
+    const m = e.message;
+    if (hasSessionAssistantUsage(m.usage)) {
+      return `a:${m.stopReason}:${m.usage.input}:${m.usage.output}:${m.usage.cacheRead}:${m.usage.cacheWrite}:${m.usage.cost.total}`;
+    }
+    return `m:${m.role}:${m.stopReason}`;
+  }
+  return `e:${e.type}`;
+}
+
+export class SessionTokenStatsCache {
+  private _processedCount = -1;
+  private _tailSignature = "";
+  private _tailEvent: unknown = undefined;
+  
+  private _prefixLedger = new TokenLedger();
+  private _lastSnapshot: LedgerSnapshot | null = null;
+
+  get(events: readonly unknown[]): SessionTokenStats {
+    const totalCount = events.length;
+    const currentTail = totalCount > 0 ? events[totalCount - 1] : undefined;
+    const currentTailSignature = computeEventSignature(currentTail);
+
+    if (
+      this._lastSnapshot &&
+      this._processedCount === totalCount &&
+      this._tailEvent === currentTail &&
+      this._tailSignature === currentTailSignature
+    ) {
+      return this._lastSnapshot;
+    }
+
+    const canExtend = this._lastSnapshot !== null && 
+      totalCount > this._processedCount && 
+      (this._processedCount === 0 || (
+        events[this._processedCount - 1] === this._tailEvent && 
+        computeEventSignature(events[this._processedCount - 1]) === this._tailSignature
+      ));
+
+    let activeLedger: TokenLedger;
+
+    if (canExtend && this._lastSnapshot !== null) {
+      // Add the OLD tail to the prefix ledger, as well as any intermediate events
+      for (let i = Math.max(0, this._processedCount - 1); i < totalCount - 1; i++) {
+        this._prefixLedger.process(events[i]);
+      }
+      activeLedger = this._prefixLedger.clone();
+    } else if (
+      this._lastSnapshot !== null &&
+      this._processedCount === totalCount &&
+      this._tailEvent === currentTail
+    ) {
+      // In-place mutation of the tail event. The prefix is valid.
+      activeLedger = this._prefixLedger.clone();
+    } else {
+      this._prefixLedger = new TokenLedger();
+      for (let i = 0; i < totalCount - 1; i++) {
+        this._prefixLedger.process(events[i]);
+      }
+      activeLedger = this._prefixLedger.clone();
+    }
+
+    if (totalCount > 0) {
+      activeLedger.process(currentTail);
+    }
+
+    this._processedCount = totalCount;
+    this._tailEvent = currentTail;
+    this._tailSignature = currentTailSignature;
+    this._lastSnapshot = activeLedger.snapshot();
+
+    return this._lastSnapshot;
+  }
+
+  reset(): void {
+    this._processedCount = -1;
+    this._tailEvent = undefined;
+    this._tailSignature = "";
+    this._prefixLedger = new TokenLedger();
+    this._lastSnapshot = null;
+  }
+}