@groeponline/pi-wishcraft 0.20.0 → 0.22.0

package/src/extension/core/state.ts

@@ -41,7 +41,9 @@ export let config: PowerlineConfig = {
   invalidPlacement: null,
   welcome: true,
   stashSharpSShortcut: false,
-  queue: { captureSigil: "#" },
+  costAlert: null,
+  customItemsAuto: false,
+  queue: { captureSigil: "#", retentionHours: 24 },
   segments: {},
   presets: {},
   segmentLabels: {},
@@ -109,6 +111,8 @@ export function createRuntimeState(
     stashedEditorText: null,
     stashedPromptHistory: readPersistedStashHistory(),
     currentEditor: null,
+    costAlertNotified: false,
+    tokenBudgetNotifiedLevel: 0,
     bashModeActive: false,
     bashTranscript: new BashTranscriptStore(bashModeSettings),
     bashCompletionEngine: new BashCompletionEngine(),

package/src/extension/core/status-export.ts

@@ -0,0 +1,68 @@
+// ═══════════════════════════════════════════════════════════════════════════
+// ChefGroep status bridge. Powerline publishes its own state under a stable
+// `powerline.*` key set via `ctx.ui.setStatus`, so ChefBar and other
+// extensions can read it without depending on powerline internals. These keys
+// are hidden from powerline's own `extension_statuses` segment.
+// ═══════════════════════════════════════════════════════════════════════════
+
+export const POWERLINE_STATUS_KEYS = {
+  preset: "powerline.preset",
+  tps: "powerline.tps",
+  ports: "powerline.ports",
+} as const;
+
+/** Keys never rendered in powerline's own bar (they exist for other extensions). */
+export const HIDDEN_POWERLINE_STATUS_KEYS: ReadonlySet<string> = new Set(
+  Object.values(POWERLINE_STATUS_KEYS),
+);
+
+export interface PowerlineStatusSnapshot {
+  /** Active preset name. */
+  preset?: string;
+  /** `POWERLINE_TPS` override; `undefined` clears it (back to live rate). */
+  tps?: string | undefined;
+  /** open_ports count as text (`?` when a fleet host probe failed). */
+  ports?: string;
+}
+
+type StatusPublisherCtx = {
+  ui?: { setStatus?: (key: string, value: string | undefined) => void };
+};
+
+/**
+ * Pure: turn a partial snapshot into the exact `[statusKey, value]` writes to
+ * make. Only keys present in the snapshot are emitted (using `in` so an
+ * explicit `tps: undefined` still produces a clearing write).
+ */
+export function buildPowerlineStatusExport(
+  snapshot: PowerlineStatusSnapshot,
+): Array<[string, string | undefined]> {
+  const entries: Array<[string, string | undefined]> = [];
+  if ("preset" in snapshot) {
+    entries.push([POWERLINE_STATUS_KEYS.preset, snapshot.preset]);
+  }
+  if ("tps" in snapshot) {
+    entries.push([POWERLINE_STATUS_KEYS.tps, snapshot.tps]);
+  }
+  if ("ports" in snapshot) {
+    entries.push([POWERLINE_STATUS_KEYS.ports, snapshot.ports]);
+  }
+  return entries;
+}
+
+/** Publish only the snapshot keys present, via `ctx.ui.setStatus`. */
+export function publishPowerlineStatuses(
+  ctx: StatusPublisherCtx | null | undefined,
+  snapshot: PowerlineStatusSnapshot,
+): void {
+  const setStatus = ctx?.ui?.setStatus;
+  if (!setStatus) return;
+  for (const [key, value] of buildPowerlineStatusExport(snapshot)) {
+    setStatus(key, value);
+  }
+}
+
+/** Format a listening-port count for the status export (`?` when unknown). */
+export function formatPortsStatusValue(count: number): string {
+  return count < 0 ? "?" : String(count);
+}

package/src/extension/core/types.ts

@@ -62,6 +62,10 @@ export interface RuntimeState {
   stashedEditorText: string | null;
   stashedPromptHistory: string[];
   currentEditor: any;
+  /** True once the configured `costAlert` threshold has been notified this session. */
+  costAlertNotified: boolean;
+  /** Highest daily-budget warning already shown this session (0 / 80 / 100). */
+  tokenBudgetNotifiedLevel: 0 | 80 | 100;
   bashModeActive: boolean;
   bashTranscript: BashTranscriptStore;
   bashCompletionEngine: BashCompletionEngine;

package/src/extension/hooks/repairs.ts

@@ -2,20 +2,74 @@
  * repairs.ts
  * ---------------------------------------------------------------------------
  * Tool-input repairs vóór executie (pi's `tool_call` event heeft mutable
- * input). Alleen de reparaties die zonder schema-kennis universeel veilig
- * zijn; schema-afhankelijke repairs (bare-string-wrap, JSON-string-array,
- * placeholder-object) vereisen de validator-issue-lijst en blijven bewust
- * weg tot Pi die expose't.
+ * input). Custom/extension tools only. Order is fixed: json-parse before
+ * bare-string wrap so `'["a"]'` becomes `["a"]`, not `[['["a"]']]`.
  * ---------------------------------------------------------------------------
  */
 
 /** Degenerate markdown auto-link: link-tekst == url zonder protocol. */
 const AUTO_LINK_RE = /^\[([^\]\s]+)\]\((https?:\/\/|file:\/\/)?([^)\s]*)\)$/;
 
+const CORE_TOOLS = new Set([
+  "bash",
+  "read",
+  "edit",
+  "write",
+  "grep",
+  "find",
+  "ls",
+]);
+
+const PATH_ALIASES = ["filePath", "absolutePath", "target_file", "file_path"];
+
+const ARRAY_KEYS = new Set([
+  "files",
+  "paths",
+  "globs",
+  "args",
+  "items",
+  "patterns",
+  "include",
+  "exclude",
+  "queries",
+  "urls",
+  "commands",
+]);
+
 function isDegenerateAutoLink(linkText: string, url: string): boolean {
   return linkText === url || linkText === decodeURI(url);
 }
 
+function isArrayKey(key: string): boolean {
+  if (ARRAY_KEYS.has(key)) return true;
+  return /_(files|paths|globs|args|items|patterns)$/.test(key);
+}
+
+function looksLikePath(text: string): boolean {
+  if (/\s/.test(text)) return false;
+  return text.includes("/") || text.includes(".") || /^[a-zA-Z0-9_-]+$/.test(text);
+}
+
+function parseJsonArray(value: string): unknown[] | null {
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("[")) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    return Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function isEmptyObject(value: unknown): boolean {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    Object.keys(value as Record<string, unknown>).length === 0
+  );
+}
+
 export interface RepairResult {
   toolName: string;
   repairs: string[];
@@ -31,39 +85,58 @@ export function repairToolInput(
   input: Record<string, unknown>,
 ): RepairResult {
   const repairs: string[] = [];
-  const isBuiltin = ["bash", "read", "edit", "write", "grep", "find", "ls"].includes(
-    toolName,
-  );
-  if (isBuiltin || !input || typeof input !== "object") {
+  if (CORE_TOOLS.has(toolName) || !input || typeof input !== "object") {
     return { toolName, repairs };
   }
 
+  if (typeof input.path !== "string" || !input.path) {
+    for (const alias of PATH_ALIASES) {
+      const value = input[alias];
+      if (typeof value === "string" && looksLikePath(value)) {
+        input.path = value;
+        delete input[alias];
+        repairs.push(`path-alias:${alias}`);
+        break;
+      }
+    }
+  }
+
   for (const key of Object.keys(input)) {
     const value = input[key];
-    // null-for-optional: model stuurde null, schema wil afwezig
     if (value === null) {
       delete input[key];
       repairs.push(`null-for-optional:${key}`);
       continue;
     }
-    // markdown auto-link op pad-achtige velden: [x.md](http://x.md) → x.md
     if (typeof value === "string") {
       const m = AUTO_LINK_RE.exec(value);
       if (m && m[1] && isDegenerateAutoLink(m[1], m[3] ?? "")) {
         input[key] = m[1];
         repairs.push(`auto-link-unwrap:${key}`);
       }
+      const current = input[key];
+      if (typeof current === "string") {
+        const parsed = parseJsonArray(current);
+        if (parsed) {
+          input[key] = parsed;
+          repairs.push(`json-string-array:${key}`);
+        }
+      }
+    }
+    const afterParse = input[key];
+    if (isArrayKey(key) && isEmptyObject(afterParse)) {
+      input[key] = [];
+      repairs.push(`empty-object-placeholder:${key}`);
+      continue;
+    }
+    if (isArrayKey(key) && typeof afterParse === "string") {
+      input[key] = [afterParse];
+      repairs.push(`bare-string-wrap:${key}`);
     }
   }
   return { toolName, repairs };
 }
 
-function looksLikePath(text: string): boolean {
-  if (/\s/.test(text)) return false;
-  return text.includes("/") || text.includes(".") || /^[a-zA-Z0-9_-]+$/.test(text);
-}
-void looksLikePath;
-
 /** Repair-teller per (tool, repair) — zichtbaar via /repairs. */
 const repairCounts = new Map<string, number>();
 

package/src/extension/session/activate.ts

@@ -7,7 +7,6 @@ import { readSettings } from "../settings/settings-io.ts";
 import { registerSessionLifecycle } from "./session-lifecycle.ts";
 import { registerCommands } from "../commands/commands.ts";
 import { setupInlineInvocation } from "../skills/inline-invocation.ts";
-import { setupHooks } from "../hooks/index.ts";
 import {
   config,
   createRuntimeState,
@@ -22,9 +21,9 @@ export default function powerlineFooter(pi: ExtensionAPI) {
   registerCustomPresets(config.presets);
 
   const rt = createRuntimeState(startupSettings);
+  rt.queueStore.setSentRetentionMs(config.queue.retentionHours * 60 * 60 * 1000);
 
   registerSessionLifecycle(pi, rt);
   registerCommands(pi, rt);
   setupInlineInvocation(pi, rt);
-  setupHooks(pi, rt, process.cwd());
 }

package/src/extension/session/cost-alert.ts

@@ -0,0 +1,36 @@
+import type { CostCurrencyCode } from "../../usage/rates.ts";
+import { formatUsdCost } from "../../usage/rates.ts";
+
+/**
+ * Decide whether the once-per-session cost alert should fire. Pure and
+ * side-effect free so it can be unit-tested without a running session.
+ */
+export function shouldTriggerCostAlert(options: {
+  totalCost: number;
+  threshold: number | null | undefined;
+  alreadyNotified: boolean;
+}): boolean {
+  const { totalCost, threshold, alreadyNotified } = options;
+  if (alreadyNotified) return false;
+  if (
+    typeof threshold !== "number" ||
+    !Number.isFinite(threshold) ||
+    threshold <= 0
+  ) {
+    return false;
+  }
+  return totalCost >= threshold;
+}
+
+/** Format the one-line warning shown when the session crosses the threshold. */
+export function formatCostAlertMessage(
+  totalCostUsd: number,
+  thresholdUsd: number,
+  currency: CostCurrencyCode = "USD",
+): string {
+  const total =
+    formatUsdCost(totalCostUsd, currency) ?? `$${totalCostUsd.toFixed(2)}`;
+  const threshold =
+    formatUsdCost(thresholdUsd, currency) ?? `$${thresholdUsd.toFixed(2)}`;
+  return `Session cost reached ${total} (alert threshold ${threshold})`;
+}

package/src/extension/session/session-lifecycle.ts

@@ -15,10 +15,26 @@ import {
   onVibeToolCall,
 } from "../../working-vibes/index.ts";
 import {
+  getSessionTotalCost,
   getUsageTokenTotal,
-  hasSessionAssistantUsage,
   isSessionAssistantMessage,
 } from "../../usage/ledger.ts";
+import {
+  formatCostAlertMessage,
+  shouldTriggerCostAlert,
+} from "./cost-alert.ts";
+import {
+  formatTokenBudgetWarning,
+  parseTokenBudget,
+  tokenBudgetLevel,
+} from "../../usage/token-budget.ts";
+import {
+  recordUsageEvent,
+  loadUsageFileFromDisk,
+  tokenTotal,
+  totalsForRange,
+  dayKey,
+} from "../../usage/usage-store.ts";
 import {
   detectCustomCompactionEnabled,
   readSettings,
@@ -59,6 +75,52 @@ import {
   scheduleDismissWelcome,
 } from "../welcome/welcome-control.ts";
 
+/**
+ * Fire the configured `powerline.costAlert` warning at most once per session.
+ * Reads the running cost from the (cached) token ledger so repeated calls are
+ * cheap; a UI-less or already-notified session short-circuits immediately.
+ */
+function maybeNotifyCostAlert(rt: RuntimeState, ctx: any): void {
+  if (!ctx?.hasUI || rt.costAlertNotified) return;
+  const threshold = config.costAlert;
+  const sessionEvents = rt.sessionBranchCache.get(ctx.sessionManager);
+  const totalCost = getSessionTotalCost(rt.tokenStatsCache.get(sessionEvents));
+  if (
+    !shouldTriggerCostAlert({
+      totalCost,
+      threshold,
+      alreadyNotified: rt.costAlertNotified,
+    })
+  ) {
+    return;
+  }
+  rt.costAlertNotified = true;
+  ctx.ui.notify(
+    formatCostAlertMessage(
+      totalCost,
+      threshold as number,
+      config.segmentOptions?.cost?.currency ?? "USD",
+    ),
+    "warning",
+  );
+}
+
+function maybeNotifyTokenBudget(rt: RuntimeState, ctx: any): void {
+  if (!ctx?.hasUI) return;
+  const daily = parseTokenBudget(readSettings(ctx.cwd ?? process.cwd()).wishcraft)
+    .daily;
+  if (!daily) return;
+  const now = Date.now();
+  const todayStart = Date.parse(`${dayKey(now)}T00:00:00`);
+  const used = tokenTotal(
+    totalsForRange(loadUsageFileFromDisk(), todayStart, now + 1),
+  );
+  const { level } = tokenBudgetLevel(used, daily);
+  if (level === 0 || level <= rt.tokenBudgetNotifiedLevel) return;
+  rt.tokenBudgetNotifiedLevel = level;
+  ctx.ui.notify(formatTokenBudgetWarning(used, daily, level), "warning");
+}
+
 // Helper to extract recent agent response text (skipping thinking blocks)
 function getRecentAgentContext(ctx: any): string | undefined {
   const sessionEvents = ctx.sessionManager?.getBranch?.() ?? [];
@@ -107,6 +169,8 @@ export function registerSessionLifecycle(
     rt.lastUserPrompt = "";
     rt.isStreaming = false;
     rt.liveAssistantUsage = null;
+    rt.costAlertNotified = false;
+    rt.tokenBudgetNotifiedLevel = 0;
     rt.powerlineCompacting = false;
     rt.deliverAfterRetrySettles = false;
     rt.stashedEditorText = null;
@@ -116,6 +180,9 @@ export function registerSessionLifecycle(
     rt.bashModeSettings = parseBashModeSettings(settings, rt.resolvedShortcuts);
     rt.showLastPrompt = settings.showLastPrompt !== false;
     setConfig(parsePowerlineConfig(settings.powerline, PRESET_NAMES));
+    rt.queueStore.setSentRetentionMs(
+      config.queue.retentionHours * 60 * 60 * 1000,
+    );
     registerCustomSegments(config.segments);
     registerCustomPresets(config.presets);
     warnInvalidSegmentSettings(ctx);
@@ -154,6 +221,7 @@ export function registerSessionLifecycle(
       } else {
         dismissWelcome(rt, ctx);
       }
+      maybeNotifyTokenBudget(rt, ctx);
     }
   });
 
@@ -271,9 +339,21 @@ export function registerSessionLifecycle(
         rt.liveAssistantUsage = null;
       } else if (getUsageTokenTotal(event.message.usage) > 0) {
         rt.liveAssistantUsage = event.message.usage;
+        const usage = event.message.usage;
+        recordUsageEvent({
+          at: Date.now(),
+          model: ctx.model?.id ?? ctx.model?.name,
+          input: usage.input,
+          output: usage.output,
+          cacheRead: usage.cacheRead,
+          cacheWrite: usage.cacheWrite,
+          cost: usage.cost.total,
+        });
       }
     }
     requestImmediateStatusRender(rt, { deferDuringTyping: false });
+    maybeNotifyCostAlert(rt, ctx);
+    maybeNotifyTokenBudget(rt, ctx);
   });
 
   pi.on("turn_end", async (_event, ctx) => {
@@ -361,6 +441,7 @@ export function registerSessionLifecycle(
             );
           }
         }
+        maybeNotifyCostAlert(rt, ctx);
       }
     } catch (error) {
       if (!isStaleExtensionContextError(error)) throw error;

package/src/extension/settings/settings-io.ts

@@ -1,9 +1,13 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { join, dirname } from "node:path";
 
-import type { StatusLinePreset } from "../../config/types.ts";
+import type {
+  CustomPresetConfig,
+  StatusLinePreset,
+} from "../../config/types.ts";
 import type { PowerlineConfig } from "../../config/powerline-config.ts";
 import {
+  nextPowerlineSettingWithCustomPreset,
   nextPowerlineSettingWithOptions,
   nextPowerlineSettingWithPreset,
 } from "../../config/powerline-config.ts";
@@ -182,21 +186,6 @@ export function writePowerlineSetting(
   return writeSettingKey(cwd, "powerline", update);
 }
 
-export function writePowerlineDisabledSegmentSetting(
-  disabledSegments: string[],
-  cwd: string = process.cwd(),
-): boolean {
-  return writePowerlineSetting(cwd, (existing) => {
-    // Shorthand string (bv. "chef") is een preset-naam: bewaar 'm.
-    const base = isRecord(existing)
-      ? existing
-      : typeof existing === "string"
-        ? { preset: existing }
-        : {};
-    return { ...base, disabledSegments };
-  });
-}
-
 export function writePowerlinePresetSetting(
   preset: StatusLinePreset,
   cwd: string = process.cwd(),
@@ -206,10 +195,27 @@ export function writePowerlinePresetSetting(
   );
 }
 
+export function writePowerlineCustomPresetSetting(
+  cwd: string,
+  name: string,
+  presetDef: CustomPresetConfig,
+): boolean {
+  return writePowerlineSetting(cwd, (existingPowerlineSetting) =>
+    nextPowerlineSettingWithCustomPreset(
+      existingPowerlineSetting,
+      name,
+      presetDef,
+    ),
+  );
+}
+
 export function writePowerlineOptionSetting(
   cwd: string,
   updates: Partial<
-    Pick<PowerlineConfig, "welcome" | "stashSharpSShortcut" | "placement">
+    Pick<
+      PowerlineConfig,
+      "welcome" | "stashSharpSShortcut" | "placement" | "disabledSegments"
+    >
   >,
   currentPreset: StatusLinePreset,
 ): boolean {

package/src/extension/settings/wishcraft-config.ts

@@ -145,7 +145,8 @@ export function buildConfigGroups(settings: Record<string, unknown>): ConfigGrou
       title: "Hooks & repairs (harness-laag)",
       items: [
         { label: "Hooks ingeschakeld", path: "wishcraft.hooksEnabled", kind: "toggle", hint: "commandcode-achtige preToolUse/postToolUse/sessionStart hooks" },
-        { label: "Tool-input repairs", path: "wishcraft.repairsEnabled", kind: "toggle", hint: "null-for-optional, auto-link unwrap op custom tools" },
+        { label: "Tool-input repairs", path: "wishcraft.repairsEnabled", kind: "toggle", hint: "null-for-optional, auto-link, json-array, path aliases" },
+        { label: "Dagelijks tokenbudget", path: "wishcraft.tokenBudget.daily", kind: "number", hint: "kleurt cost-segment; blokkeert nooit. 0 = uit" },
       ],
     },
     {

package/src/extension/shortcuts/shortcuts-config.ts

@@ -348,10 +348,15 @@ export function parseBashModeSettings(
     Number.isFinite(raw.transcriptMaxBytes)
       ? Math.max(16 * 1024, Math.floor(raw.transcriptMaxBytes))
       : DEFAULT_BASH_MODE_SETTINGS.transcriptMaxBytes;
+  const initScript =
+    typeof raw.initScript === "string" && raw.initScript.trim()
+      ? raw.initScript
+      : null;
 
   return {
     toggleShortcut,
     transcriptMaxLines,
     transcriptMaxBytes,
+    initScript,
   };
 }

package/src/extension/ui/layout.ts

@@ -61,7 +61,7 @@ export function computeResponsiveLayout(
   // Get all segments: primary first, then secondary
   const mergedSegments = mergeSegmentsWithCustomItems(
     presetDef,
-    config.customItems,
+    ctx.effectiveCustomItems,
     {
       layout: config.layout,
       disabledSegments: config.disabledSegments,