@maheidem/pi-loop 0.7.0 → 0.7.1

package/index.ts

@@ -32,6 +32,7 @@ import {
 } from "./state.ts";
 import { buildLoopPanelSnapshot, formatCountdown } from "./ui/loop-panel.ts";
 import { SettingsPanel, type PanelResult } from "./ui/settings-panel.ts";
+import { loopVersion } from "./version.ts";
 
 const TAG = "[loop]";
 const TICK_CUSTOM_TYPE = "loop-tick";
@@ -83,6 +84,7 @@ export default function (pi: ExtensionAPI) {
 		const state = rt.state;
 		return [
 			`${TAG} active`,
+			`version: v${loopVersion()}`,
 			`interval: ${formatInterval(state.intervalMs)}`,
 			`next tick: ${formatCountdown(rt.nextFireAt - Date.now())}`,
 			`ticks sent: ${state.tickCount}`,
@@ -194,7 +196,7 @@ export default function (pi: ExtensionAPI) {
 			if (raw === undefined) return false;
 			const parsed = parseInterval(raw.trim());
 			if (Number.isNaN(parsed)) {
-				say(ctx, "Interval must look like 30s, 10m, 2h, or 1d.", "error");
+				say(ctx, `${TAG} Interval must look like 30s, 10m, 2h, or 1d.`, "error");
 				proposed = raw;
 				continue;
 			}
@@ -205,7 +207,7 @@ export default function (pi: ExtensionAPI) {
 		if (editedPrompt === undefined) return false;
 		const prompt = editedPrompt.trim();
 		if (!prompt) {
-			say(ctx, "Recurring prompt cannot be empty.", "error");
+			say(ctx, `${TAG} Recurring prompt cannot be empty.`, "error");
 			return false;
 		}
 
@@ -308,9 +310,10 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	pi.registerCommand("loop", {
-		description: "Open recurring-loop controls or schedule with /loop <interval> <prompt...>",
+			description:
+				"Open recurring-loop controls or schedule with /loop <interval> <prompt...>. Verbs: status (scriptable status), edit (TUI-only interval/prompt editor), stop.",
 		getArgumentCompletions: (prefix) => {
-			const values = ["status", "stop", "30s ", "5m ", "10m ", "1h "];
+			const values = ["status", "edit", "stop", "30s ", "5m ", "10m ", "1h "];
 			const matches = values.filter((value) => value.startsWith(prefix));
 			return matches.length ? matches.map((value) => ({ value, label: value })) : null;
 		},
@@ -328,6 +331,14 @@ export default function (pi: ExtensionAPI) {
 				stopLoop(ctx, "user requested");
 				return;
 			}
+			if (a === "edit") {
+				if (ctx.mode !== "tui") {
+					say(ctx, `${TAG} /loop edit opens the TUI interval/prompt editor and is panel/TUI-only — in print mode re-arm instead: /loop stop then /loop <interval> <prompt...>. /loop status shows the current schedule.`);
+					return;
+				}
+				await editSchedule(ctx, true);
+				return;
+			}
 			const parsed = parseArgs(a);
 			if (typeof parsed === "string") {
 				say(ctx, `${TAG} ${parsed}`, "error");
@@ -357,6 +368,12 @@ export default function (pi: ExtensionAPI) {
 			interval: Type.Optional(Type.String({ description: "e.g. 30s, 5m, 2h, 1d. Default 10m, min 15s." })),
 			prompt: Type.Optional(Type.String({ description: "The prompt to fire each tick, verbatim. Required for action=start." })),
 		}),
+		promptGuidelines: [
+			"Use this tool for unattended recurring work at a fixed cadence — the prompt re-fires every interval without anyone typing it.",
+			"The prompt fires verbatim on each tick, prefixed with a one-line provenance header ([loop tick #N · scheduled by /loop, not typed by the user]).",
+			"The interval is fixed at arm time; to change it, stop (action: stop) and re-arm with the new interval.",
+			"Stop the loop once the goal is reached — leftover loops keep firing until stopped or the session ends.",
+		],
 		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
 			if (params.action === "start") {
 				const parsed = parseArgs(`${params.interval ?? ""} ${params.prompt ?? ""}`.trim());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maheidem/pi-loop",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "type": "module",
   "description": "Pi extension: /loop \u2014 a generic recurring-prompt loop (Claude Code /loop style) delivered as in-session steer custom messages. Skills (e.g. shepherd) are consumers of /loop, not part of it.",
   "keywords": [
@@ -13,8 +13,10 @@
   "files": [
     "index.ts",
     "state.ts",
+    "version.ts",
     "ui/settings-panel.ts",
     "ui/loop-panel.ts",
+    "ui/version.ts",
     "skills/",
     "README.md",
     "LICENSE"

package/ui/version.ts

@@ -0,0 +1,69 @@
+/**
+ * ui/version.ts — canonical loaded-version provenance (S2, pi-panel-kit
+ * stage 1).
+ *
+ * WHY THIS EXISTS
+ * A running Pi session keeps whatever extension code it loaded at startup;
+ * newer installs (npm store or by-path) only apply after `/reload`. A stale
+ * in-process copy is indistinguishable from a fresh one unless every status
+ * line, panel summary, and tool card carries the version actually EXECUTING.
+ * This helper reads that version from the extension's own `package.json` —
+ * never hard-coded, never baked at build time.
+ *
+ * Vendored byte-identically into consumers (guard: `node
+ * skills/pi-extension-builder/scripts/check-vendored.mjs`); each extension
+ * keeps a thin wrapper (`version.ts` at its package root) that exports its
+ * original function name and passes the `package.json` path resolved from
+ * THE WRAPPER'S module URL — a vendored copy sits in `ui/` and cannot find
+ * the package root by itself, which is exactly why the path is a parameter.
+ *
+ * Pi-free by design: node built-ins only, no imports from sibling modules.
+ */
+
+import * as fs from "node:fs";
+
+export interface ExtensionVersionOptions {
+	/**
+	 * Absolute path to the extension's `package.json`. Resolve it from the
+	 * wrapper's own module URL (`path.join(dirname(fileURLToPath(import.meta.url)), "package.json")`)
+	 * so the string is anchored to the code actually executing, not the cwd.
+	 */
+	packageJsonPath: string;
+	/**
+	 * Short extension name for composed headers. When set, the result is
+	 * `label vX.Y.Z` (the `[delegate v0.3.2 …]` pattern used in result
+	 * headers). Default: no label, bare version (status lines and panel
+	 * summaries render their own prefixes).
+	 */
+	label?: string;
+	/**
+	 * Verbatim suffix appended after the version, e.g.
+	 * `" (loaded at session start; /reload picks up newer installs)"`.
+	 * Default: none. Call sites that interpolate the suffix themselves keep
+	 * passing nothing — identical output either way.
+	 */
+	suffix?: string;
+	/** Returned when `package.json` is unreadable/unparsable or lacks `version`. Default `"unknown"`. */
+	fallback?: string;
+}
+
+/** Raw versions keyed by resolved package.json path; read once per process. */
+const cache = new Map<string, string>();
+
+/** The `version` field of the extension's package.json (never a hardcoded string). */
+export function extensionVersion(options: ExtensionVersionOptions): string {
+	const fallback = options.fallback ?? "unknown";
+	let version = cache.get(options.packageJsonPath);
+	if (version === undefined) {
+		try {
+			const pkg = JSON.parse(fs.readFileSync(options.packageJsonPath, "utf8")) as {
+				version?: string;
+			};
+			version = pkg.version ?? fallback;
+		} catch {
+			version = fallback;
+		}
+		cache.set(options.packageJsonPath, version);
+	}
+	return `${options.label ? `${options.label} v` : ""}${version}${options.suffix ?? ""}`;
+}

package/version.ts

@@ -0,0 +1,24 @@
+/**
+ * loop — loaded-version provenance.
+ *
+ * A running Pi session keeps whatever extension code it loaded at startup;
+ * newer npm-store installs only apply after /reload. The /loop status
+ * output therefore carries the version actually executing, so a stale copy
+ * in this process is self-evident instead of mysterious.
+ *
+ * Thin wrapper over the canonical helper vendored at `ui/version.ts`
+ * (kit source: `skills/pi-extension-builder/assets/control-panel/…`); the
+ * package.json path is resolved from THIS module's URL.
+ */
+
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { extensionVersion } from "./ui/version.ts";
+
+export function loopVersion(): string {
+	return extensionVersion({
+		packageJsonPath: path.join(path.dirname(fileURLToPath(import.meta.url)), "package.json"),
+		suffix: " (loaded at session start; /reload picks up newer installs)",
+	});
+}