@groeponline/pi-wishcraft 0.22.2 → 0.23.1

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## [Unreleased]
 
+## [0.23.1] - 2026-08-20
+
+## [0.23.0] - 2026-08-20
+
+### Added
+- `powerline.skills.count` status export, published on session start and after skill-cache invalidation.
+- Read-tool continuation hints on partial core `read` results when the core output omits a range or offset summary.
+
+### Changed
+- Powerline Status menu keeps only ports, TPS, and toggle (removed unimplemented diagnostics entries).
+
 ## [0.22.2] - 2026-08-20
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groeponline/pi-wishcraft",
-  "version": "0.22.2",
+  "version": "0.23.1",
   "description": "Wishcraft cockpit for the pi coding agent — powerline status, vibes, idea inbox, bash mode, and full customization.",
   "type": "module",
   "files": [

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

@@ -9,6 +9,7 @@ export const POWERLINE_STATUS_KEYS = {
   preset: "powerline.preset",
   tps: "powerline.tps",
   ports: "powerline.ports",
+  skillsCount: "powerline.skills.count",
 } as const;
 
 /** Keys never rendered in powerline's own bar (they exist for other extensions). */
@@ -23,6 +24,8 @@ export interface PowerlineStatusSnapshot {
   tps?: string | undefined;
   /** open_ports count as text (`?` when a fleet host probe failed). */
   ports?: string;
+  /** Skill catalog length as a decimal string. */
+  skillsCount?: string;
 }
 
 type StatusPublisherCtx = {
@@ -47,9 +50,17 @@ export function buildPowerlineStatusExport(
   if ("ports" in snapshot) {
     entries.push([POWERLINE_STATUS_KEYS.ports, snapshot.ports]);
   }
+  if ("skillsCount" in snapshot) {
+    entries.push([POWERLINE_STATUS_KEYS.skillsCount, snapshot.skillsCount]);
+  }
   return entries;
 }
 
+/** Format a skill-catalog length for the status export. */
+export function formatSkillsCountStatusValue(count: number): string {
+  return String(count);
+}
+
 /** Publish only the snapshot keys present, via `ctx.ui.setStatus`. */
 export function publishPowerlineStatuses(
   ctx: StatusPublisherCtx | null | undefined,

package/src/extension/session/read-hints.ts

@@ -0,0 +1,147 @@
+import { readSettings } from "../settings/settings-io.ts";
+
+export interface ReadToolInput {
+  offset?: number;
+  limit?: number;
+}
+
+export interface ReadHintDetails {
+  truncation?: {
+    totalLines?: number;
+    outputLines?: number;
+  };
+}
+
+const CORE_SHOWING_LINES =
+  /^\[Showing lines \d+[–-]\d+(?: of \d+)?\.(?: Use offset=\d+ to continue\.)?\]$/i;
+const CORE_MORE_LINES =
+  /^\[?\d+ more lines in file\. Use offset=\d+ to continue\.?\]?$/i;
+const OWN_READ_HINT = /^\d+ lines, showing \d+[–-]\d+, next offset \d+$/;
+
+function isCoreRangeFooter(line: string): boolean {
+  const footer = line.trim();
+  return (
+    CORE_SHOWING_LINES.test(footer) ||
+    CORE_MORE_LINES.test(footer) ||
+    OWN_READ_HINT.test(footer)
+  );
+}
+
+function coreFooter(text: string): string {
+  const lines = text.split("\n");
+  while (lines.length > 0 && lines[lines.length - 1]!.trim() === "") lines.pop();
+  return lines[lines.length - 1]?.trim() ?? "";
+}
+
+/** Default on. `wishcraft.readHints: false` is the opt-out. */
+export function readHintsEnabled(wishcraftSettings: unknown): boolean {
+  if (
+    !wishcraftSettings ||
+    typeof wishcraftSettings !== "object" ||
+    Array.isArray(wishcraftSettings)
+  ) {
+    return true;
+  }
+  return (wishcraftSettings as Record<string, unknown>).readHints !== false;
+}
+
+/** True when core read output already carries an offset/range continuation line. */
+export function coreReadResultHasRangeSummary(
+  text: string,
+  _details?: ReadHintDetails,
+): boolean {
+  return isCoreRangeFooter(coreFooter(text));
+}
+
+function countContentLines(text: string): number {
+  const lines = text.split("\n");
+  let end = lines.length;
+  while (end > 0 && lines[end - 1] === "") end--;
+  if (end > 0 && isCoreRangeFooter(lines[end - 1]!)) end--;
+  return end;
+}
+
+/** Whether to append a one-line read continuation hint to a core read result. */
+export function shouldAppendReadHint(
+  input: ReadToolInput | null | undefined,
+  text: string,
+  details?: ReadHintDetails,
+): boolean {
+  if (!input) return false;
+  if (input.offset === undefined && input.limit === undefined) return false;
+  if (coreReadResultHasRangeSummary(text, details)) return false;
+
+  const lineCount = countContentLines(text);
+  if (lineCount === 0) return false;
+
+  const start = input.offset ?? 1;
+  const end = start + lineCount - 1;
+  const total = details?.truncation?.totalLines;
+  if (total !== undefined && end >= total) return false;
+  if (input.limit !== undefined && lineCount < input.limit) return false;
+
+  return true;
+}
+
+/** Format the English continuation hint for a partial read window. */
+export function formatReadHint(
+  input: ReadToolInput,
+  text: string,
+  details?: ReadHintDetails,
+): string {
+  const start = input.offset ?? 1;
+  const lineCount = countContentLines(text);
+  const end = start + lineCount - 1;
+  const next = end + 1;
+  const total = details?.truncation?.totalLines;
+  if (total !== undefined) {
+    return `${total} lines, showing ${start}–${end}, next offset ${next}`;
+  }
+  return `${lineCount} lines, showing ${start}–${end}, next offset ${next}`;
+}
+
+export function extractReadToolResultText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((block) =>
+    block && typeof block === "object" && "text" in block
+      ? String((block as { text?: unknown }).text ?? "")
+      : "",
+  ).join("\n");
+}
+
+/**
+ * Append a continuation hint to a core `read` tool_result.
+ * Returns a replacement payload; never mutates `event.input` or `event.content`.
+ */
+export function appendReadHintToEvent(event: {
+  input?: unknown;
+  content?: unknown;
+  details?: unknown;
+}): { content: Array<{ type: "text"; text: string }> } | undefined {
+  const text = extractReadToolResultText(event.content);
+  const input = event.input as ReadToolInput | undefined;
+  const details = event.details as ReadHintDetails | undefined;
+  if (!shouldAppendReadHint(input, text, details) || !input) return undefined;
+  if (!Array.isArray(event.content)) return undefined;
+  const hint = formatReadHint(input, text, details);
+  return {
+    content: [
+      ...(event.content as Array<{ type: "text"; text: string }>),
+      { type: "text", text: hint },
+    ],
+  };
+}
+
+/** Apply the opt-out and append a hint without mutating `event.input`. */
+export function maybeAppendReadHint(
+  event: {
+    input?: unknown;
+    content?: unknown;
+    details?: unknown;
+  },
+  cwd?: string,
+): { content: Array<{ type: "text"; text: string }> } | undefined {
+  if (!readHintsEnabled(readSettings(cwd).wishcraft)) return undefined;
+  return appendReadHintToEvent(event);
+}

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

@@ -70,10 +70,12 @@ import {
 import { CONTEXT_STATUS_RENDER_MS } from "../core/constants.ts";
 import type { RuntimeState } from "../core/types.ts";
 import { isStaleExtensionContextError } from "./stale-context.ts";
+import { dismissWelcome, scheduleDismissWelcome } from "../welcome/welcome-control.ts";
 import {
-  dismissWelcome,
-  scheduleDismissWelcome,
-} from "../welcome/welcome-control.ts";
+  bindSkillsCountPublisher,
+  clearSkillsCountPublisher,
+} from "../skills/skill-status.ts";
+import { maybeAppendReadHint } from "./read-hints.ts";
 
 /**
  * Fire the configured `powerline.costAlert` warning at most once per session.
@@ -160,6 +162,7 @@ export function registerSessionLifecycle(
 ): void {
   // Track session start
   pi.on("session_start", async (event, ctx) => {
+    clearSkillsCountPublisher();
     rt.shellSession?.dispose();
     rt.shellSession = null;
     rt.sessionGeneration++;
@@ -196,6 +199,7 @@ export function registerSessionLifecycle(
 
     if (ctx.hasUI) {
       ctx.ui.setStatus("stash", undefined);
+      bindSkillsCountPublisher(ctx);
       const pendingIdeas = rt.queueStore
         .activeItems(getQueueContext(ctx))
         .filter((item) => item.intent === "idea").length;
@@ -226,6 +230,7 @@ export function registerSessionLifecycle(
   });
 
   pi.on("session_shutdown", async (_event, ctx) => {
+    clearSkillsCountPublisher();
     rt.sessionGeneration++;
     rt.dismissWelcomeOverlay?.();
     rt.dismissWelcomeOverlay = null;
@@ -257,7 +262,7 @@ export function registerSessionLifecycle(
   });
 
   // Invalidate git status on file changes, trigger re-render on potential branch changes
-  pi.on("tool_result", async (event) => {
+  pi.on("tool_result", async (event, ctx) => {
     if (event.toolName === "write" || event.toolName === "edit") {
       invalidateGitStatus();
       requestStatusRender(rt);
@@ -266,6 +271,9 @@ export function registerSessionLifecycle(
     if (event.toolName === "bash" && event.input?.command) {
       invalidateGitForCommand(rt, String(event.input.command));
     }
+    if (event.toolName === "read") {
+      return maybeAppendReadHint(event, ctx?.cwd);
+    }
   });
 
   // Also catch user escape commands (! prefix)

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

@@ -139,6 +139,7 @@ export function buildConfigGroups(settings: Record<string, unknown>): ConfigGrou
       title: "Skills",
       items: [
         { label: "Inline-expansie /command en $skill", path: "wishcraft.inlineSkills", kind: "toggle", hint: "nog niet actief zonder herstart" },
+        { label: "Read hints", path: "wishcraft.readHints", kind: "toggle", hint: "off = no continuation hint after partial reads" },
       ],
     },
     {

package/src/extension/skills/skill-registry.ts

@@ -96,6 +96,11 @@ let cachedAt = 0;
 let cachedEntries: SkillEntry[] | null = null;
 let cachedPathMap: Map<string, string> | null = null;
 let cachedCwd: string | null = null;
+let onCacheInvalidated: (() => void) | null = null;
+
+export function setSkillCacheInvalidationHandler(handler: (() => void) | null): void {
+  onCacheInvalidated = handler;
+}
 
 const usageCache = new Map<string, SkillUsage>();
 let usageLoaded = false;
@@ -106,6 +111,7 @@ export function invalidateSkillCache(): void {
   cachedEntries = null;
   cachedPathMap = null;
   cachedCwd = null;
+  onCacheInvalidated?.();
 }
 
 /** Legacy prompts/loose-md dirs die inline-invocation altijd al scanden. */

package/src/extension/skills/skill-status.ts

@@ -0,0 +1,37 @@
+import {
+  formatSkillsCountStatusValue,
+  publishPowerlineStatuses,
+} from "../core/status-export.ts";
+import {
+  invalidateSkillCache,
+  loadSkillCatalog,
+  setSkillCacheInvalidationHandler,
+} from "./skill-registry.ts";
+
+type SkillsCountCtx = {
+  cwd?: string;
+  ui?: { setStatus?: (key: string, value: string | undefined) => void };
+};
+
+function publishSkillsCount(ctx: SkillsCountCtx): void {
+  publishPowerlineStatuses(ctx, {
+    skillsCount: formatSkillsCountStatusValue(
+      loadSkillCatalog(ctx.cwd ?? process.cwd()).length,
+    ),
+  });
+}
+
+/** Drop the session-scoped publisher so later invalidations cannot use a stale UI. */
+export function clearSkillsCountPublisher(): void {
+  setSkillCacheInvalidationHandler(null);
+}
+
+/**
+ * Publish `powerline.skills.count` now and after every skill-cache invalidation.
+ * Replaces any previous session callback first.
+ */
+export function bindSkillsCountPublisher(ctx: SkillsCountCtx): void {
+  clearSkillsCountPublisher();
+  setSkillCacheInvalidationHandler(() => publishSkillsCount(ctx));
+  invalidateSkillCache();
+}

package/src/extension/ui/powerline-menu.ts

@@ -21,13 +21,6 @@ export function buildPowerlineMenuItems(): PowerlineMenuNode[] {
         { id: "ports", label: "Open ports", description: "Full listening list" },
         { id: "tps", label: "TPS detail", description: "Live 1s window or override" },
         { id: "toggle", label: "Toggle powerline", description: "Use /powerline to enable or disable" },
-        { id: "cpu", label: "CPU usage", description: "Current process CPU usage" },
-        { id: "memory", label: "Memory usage", description: "Current process memory" },
-        { id: "network", label: "Network status", description: "Network interface status" },
-        { id: "uptime", label: "System uptime", description: "Host uptime" },
-        { id: "version", label: "Version info", description: "Runtime and application versions" },
-        { id: "logs", label: "Recent logs", description: "Show recent status messages" },
-        { id: "diagnostics", label: "Diagnostics", description: "Run powerline diagnostics" },
       ],
     },
   ];

package/src/segments/custom.ts

@@ -35,7 +35,9 @@ function runCommandCached(
       commandCache.set(command, { at: now, value: out });
     return out;
   } catch {
-    return null;
+    // Preserve command failures so renderSegment can isolate this segment and
+    // expose a visible fault marker instead of silently hiding it.
+    throw new Error(`Command failed: ${command}`);
   }
 }
 

package/src/segments/registry.ts

@@ -164,16 +164,24 @@ export function renderSegment(
   id: StatusLineSegmentId,
   ctx: SegmentContext,
 ): RenderedSegment {
-  let rendered: RenderedSegment;
-  if (isCustomSegmentId(id)) {
-    const customId = id.slice("custom:".length);
-    const computed = customComputedSegments.get(customId);
-    rendered = computed
-      ? computed.render(ctx)
-      : renderCustomSegment(id, ctx);
-  } else {
-    const segment = SEGMENTS[id];
-    rendered = segment ? segment.render(ctx) : { content: "", visible: false };
+  try {
+    let rendered: RenderedSegment;
+    if (isCustomSegmentId(id)) {
+      const customId = id.slice("custom:".length);
+      const computed = customComputedSegments.get(customId);
+      rendered = computed
+        ? computed.render(ctx)
+        : renderCustomSegment(id, ctx);
+    } else {
+      const segment = SEGMENTS[id];
+      rendered = segment ? segment.render(ctx) : { content: "", visible: false };
+    }
+    return applySegmentDecoration(id, ctx, rendered);
+  } catch {
+    // ponytail: per-segment fault isolation. A throwing segment (most often a
+    // user `command` custom segment with a failing script) must not blank the
+    // whole footer; surface a visible `!id` marker so the operator sees
+    // which segment broke. No per-render log: the bar repaints ~30/s.
+    return { content: `!${id}`, visible: true };
   }
-  return applySegmentDecoration(id, ctx, rendered);
 }

package/src/segments/system.ts

@@ -180,7 +180,21 @@ export function countListeningPorts(includeUdp = false, host?: string): number {
     return host ? -1 : readProcListeningPorts(includeUdp);
   }
 
-  const lines = out
+  return parseListeningPortsFromText(out).size;
+}
+
+/**
+ * Pure port-count parser shared by `countListeningPorts`. Accepts `ss` and
+ * `netstat` output. The port separator is `:` on Linux/`ss`/`lsof` but `.` on
+ * macOS `netstat` (`*.5900`, `127.0.0.1.631`); matching both keeps the
+ * open-ports segment honest on macOS.
+ *
+ * ponytail: assumes LISTEN rows always carry a port on the local-address
+ * column; a bare IPv4 with no port (not emitted by LISTEN output) would
+ * false-match the `.<digits>` form.
+ */
+export function parseListeningPortsFromText(text: string): Set<number> {
+  const lines = text
     .split("\n")
     .map((l) => l.trim())
     .filter(Boolean);
@@ -189,14 +203,14 @@ export function countListeningPorts(includeUdp = false, host?: string): number {
   for (const line of lines.slice(start)) {
     // ss/netstat put the local address at different columns; take the first addr:port token
     for (const col of line.split(/\s+/)) {
-      const m = /:(\d+)$/.exec(col);
+      const m = /(?::|\.)(\d+)$/.exec(col);
       if (m) {
         ports.add(Number(m[1]));
         break;
       }
     }
   }
-  return ports.size;
+  return ports;
 }
 
 function readProcListeningPorts(includeUdp: boolean): number {
@@ -259,7 +273,7 @@ export function parseOpenPortProcesses(text: string): OpenPortProcess[] {
     // numeric Recv-Q there. That tells us which local-address column to use.
     const isSsRow = !/^\d+$/.test(tokens[1] ?? "");
     const local = isSsRow ? tokens[4] : tokens[3];
-    const portMatch = local ? /:(\d+)$/.exec(local) : null;
+    const portMatch = local ? /(?::|\.)(\d+)$/.exec(local) : null;
     if (!portMatch) continue;
 
     let process: string | null = null;
@@ -275,7 +289,7 @@ export function parseOpenPortProcesses(text: string): OpenPortProcess[] {
     entries.push({
       port: Number(portMatch[1]),
       proto: tokens[0].toLowerCase().startsWith("udp") ? "udp" : "tcp",
-      address: local.replace(/:(\d+)$/, ""),
+      address: local.replace(/(?::|\.)(\d+)$/, ""),
       process,
     });
   }