@groeponline/pi-wishcraft 0.17.3

package/src/extension/shortcuts-router.ts

@@ -0,0 +1,383 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { copyToClipboard } from "@earendil-works/pi-coding-agent";
+import { isKeyRelease, type SelectItem } from "@earendil-works/pi-tui";
+
+import {
+  matchesConfiguredShortcut,
+  matchesStashShortcutInput,
+} from "../shortcuts/matching.ts";
+import { hasNonWhitespaceText } from "./prompt-history.ts";
+import {
+  buildStashPreview,
+  pushStashHistory,
+  persistStashHistory,
+} from "./stash-history.ts";
+import { readRecentProjectPrompts } from "./prompt-history.ts";
+import { showSelectOverlay } from "./menu-views.ts";
+import {
+  captureCurrentProjectIdea,
+  captureIdeaFromText,
+  openQueuePicker,
+} from "./queue-integration.ts";
+import { setBashModeActive } from "./bash-mode-actions.ts";
+import { config } from "./state.ts";
+import {
+  PROJECT_PROMPT_HISTORY_LIMIT,
+  STASH_PREVIEW_WIDTH,
+} from "./constants.ts";
+import type {
+  PowerlineShortcutAction,
+  RuntimeState,
+} from "./types.ts";
+
+export function getCurrentEditorText(ctx: any, editor: any): string {
+  const editorText = editor?.getExpandedText?.();
+  if (typeof editorText === "string" && editorText.length > 0)
+    return editorText;
+  return ctx.ui.getEditorText?.() ?? editorText ?? "";
+}
+
+export function addStashHistoryEntry(rt: RuntimeState, text: string): void {
+  const changed = pushStashHistory(rt.stashedPromptHistory, text);
+  if (!changed) {
+    return;
+  }
+
+  persistStashHistory(rt.stashedPromptHistory);
+}
+
+export function copyTextToClipboard(
+  ctx: any,
+  text: string,
+  successMessage?: string,
+): void {
+  copyToClipboard(text);
+  if (successMessage) {
+    ctx.ui.notify(successMessage, "info");
+  }
+}
+
+export function getEditorTextForClipboard(
+  rt: RuntimeState,
+  ctx: any,
+): string | null {
+  const text = getCurrentEditorText(ctx, rt.currentEditor);
+  if (hasNonWhitespaceText(text)) {
+    return text;
+  }
+
+  ctx.ui.notify("Editor is empty", "info");
+  return null;
+}
+
+export async function selectStashedPromptFromHistory(
+  rt: RuntimeState,
+  ctx: any,
+): Promise<string | null> {
+  const historyItems = [...rt.stashedPromptHistory];
+  const items: SelectItem[] = historyItems.map((entry, index) => ({
+    value: String(index),
+    label: `#${index + 1} ${buildStashPreview(entry, STASH_PREVIEW_WIDTH)}`,
+  }));
+
+  const selected = await showSelectOverlay(
+    ctx,
+    "Stash history",
+    "↑↓ navigate • enter insert • esc cancel",
+    items,
+    Math.min(items.length, 10),
+  );
+  if (!selected) return null;
+
+  const i = Number.parseInt(selected.value, 10);
+  return historyItems[i] ?? null;
+}
+
+export async function selectProjectPromptFromHistory(
+  ctx: any,
+  prompts: string[],
+): Promise<string | null> {
+  const items: SelectItem[] = prompts.map((entry, index) => ({
+    value: String(index),
+    label: `#${index + 1} ${buildStashPreview(entry, STASH_PREVIEW_WIDTH)}`,
+  }));
+
+  const selected = await showSelectOverlay(
+    ctx,
+    "Recent project prompts",
+    "↑↓ navigate • enter insert • esc cancel",
+    items,
+    Math.min(items.length, 10),
+  );
+  if (!selected) return null;
+
+  const i = Number.parseInt(selected.value, 10);
+  return prompts[i] ?? null;
+}
+
+export async function selectPromptHistorySource(
+  ctx: any,
+  stashCount: number,
+  projectPromptCount: number,
+): Promise<"stash" | "project" | null> {
+  const items: SelectItem[] = [];
+
+  if (stashCount > 0) {
+    items.push({
+      value: "stash",
+      label: "Stashed prompts",
+      description: `${stashCount} saved`,
+    });
+  }
+
+  if (projectPromptCount > 0) {
+    items.push({
+      value: "project",
+      label: "Recent project prompts",
+      description: `${projectPromptCount} recent`,
+    });
+  }
+
+  if (items.length === 0) {
+    return null;
+  }
+
+  if (items.length === 1) {
+    return items[0]?.value === "project" ? "project" : "stash";
+  }
+
+  const selected = await showSelectOverlay(
+    ctx,
+    "Prompt history",
+    "↑↓ navigate • enter open • esc cancel",
+    items,
+    items.length,
+  );
+  if (!selected) return null;
+
+  return selected.value === "project" ? "project" : "stash";
+}
+
+export async function insertSelectedPromptHistoryEntry(
+  rt: RuntimeState,
+  ctx: any,
+  selected: string,
+): Promise<void> {
+  const currentText = getCurrentEditorText(ctx, rt.currentEditor);
+  if (!hasNonWhitespaceText(currentText)) {
+    ctx.ui.setEditorText(selected);
+    ctx.ui.notify("Inserted prompt", "info");
+    return;
+  }
+
+  const action = await ctx.ui.select("Insert prompt", [
+    "Replace",
+    "Append",
+    "Cancel",
+  ]);
+
+  if (action === "Replace") {
+    ctx.ui.setEditorText(selected);
+    ctx.ui.notify("Replaced editor with prompt", "info");
+    return;
+  }
+
+  if (action === "Append") {
+    const separator =
+      currentText.endsWith("\n") || selected.startsWith("\n") ? "" : "\n";
+    ctx.ui.setEditorText(`${currentText}${separator}${selected}`);
+    ctx.ui.notify("Appended prompt", "info");
+  }
+}
+
+export async function handleSelectedStashHistoryEntry(
+  rt: RuntimeState,
+  ctx: any,
+  selected: string,
+): Promise<void> {
+  const action = await ctx.ui.select("Stashed prompt", [
+    "Insert",
+    "Promote to idea",
+    "Cancel",
+  ]);
+
+  if (action === "Insert") {
+    await insertSelectedPromptHistoryEntry(rt, ctx, selected);
+    return;
+  }
+
+  if (action === "Promote to idea") {
+    try {
+      captureIdeaFromText(rt, ctx, selected);
+    } catch (error) {
+      ctx.ui.notify(
+        error instanceof Error ? error.message : String(error),
+        "error",
+      );
+    }
+  }
+}
+
+export function isStashShortcutInput(data: string): boolean {
+  return matchesStashShortcutInput(data, {
+    includePrintableSharpS: config.stashSharpSShortcut,
+  });
+}
+
+export function isPromptHistoryShortcutInput(
+  rt: RuntimeState,
+  data: string,
+): boolean {
+  return (
+    matchesConfiguredShortcut(data, rt.resolvedShortcuts.stashHistory) ||
+    (rt.resolvedShortcuts.stashHistory === "ctrl+alt+h" &&
+      (/^\x1b\[104(?::\d*)?(?::\d*)?;7(?::\d+)?u$/.test(data) ||
+        data === "\x1b[27;7;104~" ||
+        data === "\x1b[27;7;72~"))
+  );
+}
+
+export function getPowerlineShortcutAction(
+  rt: RuntimeState,
+  data: string,
+): PowerlineShortcutAction | null {
+  if (isKeyRelease(data)) return null;
+
+  if (isPromptHistoryShortcutInput(rt, data)) {
+    return { kind: "stashHistory" };
+  }
+  if (matchesConfiguredShortcut(data, rt.resolvedShortcuts.copyEditor)) {
+    return { kind: "copyEditor" };
+  }
+  if (matchesConfiguredShortcut(data, rt.resolvedShortcuts.cutEditor)) {
+    return { kind: "cutEditor" };
+  }
+  if (matchesConfiguredShortcut(data, rt.resolvedShortcuts.ideaCapture)) {
+    return { kind: "ideaCapture" };
+  }
+  if (matchesConfiguredShortcut(data, rt.resolvedShortcuts.queueOpen)) {
+    return { kind: "queueOpen" };
+  }
+  if (matchesConfiguredShortcut(data, rt.bashModeSettings.toggleShortcut)) {
+    return { kind: "bashMode" };
+  }
+
+  return null;
+}
+
+export function runPowerlineShortcut(
+  pi: ExtensionAPI,
+  rt: RuntimeState,
+  ctx: any,
+  action: PowerlineShortcutAction,
+): void {
+  if (action.kind === "stashHistory") {
+    void openStashHistory(rt, ctx);
+    return;
+  }
+
+  if (action.kind === "copyEditor" || action.kind === "cutEditor") {
+    const text = getEditorTextForClipboard(rt, ctx);
+    if (!text) return;
+
+    copyTextToClipboard(
+      ctx,
+      text,
+      action.kind === "copyEditor" ? "Copied editor text" : undefined,
+    );
+    if (action.kind === "cutEditor") {
+      ctx.ui.setEditorText("");
+      ctx.ui.notify("Cut editor text", "info");
+    }
+    return;
+  }
+
+  if (action.kind === "ideaCapture") {
+    const text = getEditorTextForClipboard(rt, ctx);
+    if (!text) return;
+
+    const item = captureCurrentProjectIdea(rt, ctx, text);
+    if (item) {
+      ctx.ui.setEditorText("");
+    }
+    return;
+  }
+
+  if (action.kind === "queueOpen") {
+    void openQueuePicker(pi, rt, ctx, "queue");
+    return;
+  }
+
+  if (action.kind === "bashMode") {
+    void setBashModeActive(rt, !rt.bashModeActive, ctx);
+    return;
+  }
+}
+
+export function stashOrRestoreEditorText(rt: RuntimeState, ctx: any): void {
+  const rawText = getCurrentEditorText(ctx, rt.currentEditor);
+  const hasStash = rt.stashedEditorText !== null;
+
+  if (!hasNonWhitespaceText(rawText)) {
+    if (!hasStash) {
+      ctx.ui.notify("Nothing to stash", "info");
+      return;
+    }
+
+    ctx.ui.setEditorText(rt.stashedEditorText);
+    rt.stashedEditorText = null;
+    ctx.ui.setStatus("stash", undefined);
+    ctx.ui.notify("Stash restored", "info");
+    return;
+  }
+
+  rt.stashedEditorText = rawText;
+  addStashHistoryEntry(rt, rawText);
+  ctx.ui.setEditorText("");
+  ctx.ui.setStatus("stash", "stash");
+  ctx.ui.notify(hasStash ? "Stash updated" : "Text stashed", "info");
+}
+
+export async function openStashHistory(
+  rt: RuntimeState,
+  ctx: any,
+): Promise<void> {
+  let projectPrompts: string[] = [];
+
+  try {
+    projectPrompts = readRecentProjectPrompts(
+      ctx.cwd,
+      PROJECT_PROMPT_HISTORY_LIMIT,
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    ctx.ui.notify(`Failed to load project prompts: ${message}`, "warning");
+  }
+
+  if (rt.stashedPromptHistory.length === 0 && projectPrompts.length === 0) {
+    ctx.ui.notify("No prompt history yet", "info");
+    return;
+  }
+
+  const source = await selectPromptHistorySource(
+    ctx,
+    rt.stashedPromptHistory.length,
+    projectPrompts.length,
+  );
+  if (!source) {
+    return;
+  }
+
+  const selected =
+    source === "project"
+      ? await selectProjectPromptFromHistory(ctx, projectPrompts)
+      : await selectStashedPromptFromHistory(rt, ctx);
+  if (!selected) return;
+
+  if (source === "stash") {
+    await handleSelectedStashHistoryEntry(rt, ctx, selected);
+    return;
+  }
+
+  await insertSelectedPromptHistoryEntry(rt, ctx, selected);
+}

package/src/extension/skills/inline-invocation.ts

@@ -0,0 +1,174 @@
+/**
+ * inline-invocation.ts
+ * ------------------------------------------------------------------------
+ * Pi.dev extension — pi-wishcraft
+ * 
+ * Simpele inline trigger expansie zoals Cursor (met /) en Codex (met $)
+ * 
+ * Gebruik:
+ *   - /command -> vervangt door inhoud van command.md skill file
+ *   - $skill   -> vervangt door inhoud van skill.md skill file
+ * 
+ * Werkt midden in prompts, ondersteunt meerdere triggers per bericht.
+ * ------------------------------------------------------------------------
+ */
+
+import { readFileSync, existsSync, readdirSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { stripFrontmatter } from "../../core/frontmatter.ts";
+import { getAgentPath } from "../../paths/agent-dirs.ts";
+import { logDiscoveryError } from "../../welcome/discover.ts";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { RuntimeState } from "../types.ts";
+
+const EXTENSION_DIR = dirname(fileURLToPath(import.meta.url));
+
+let availableSkills: Map<string, string> | undefined;
+
+function discoverSkills(): void {
+if (availableSkills) return;
+const discovered = new Map<string, string>();
+const dirs = [
+  getAgentPath("skills"),
+  join(process.cwd(), ".pi", "skills"),
+  join(process.cwd(), "skills"),
+  getAgentPath("prompts"),
+  join(process.cwd(), ".pi", "prompts"),
+  join(process.cwd(), "prompts"),
+  EXTENSION_DIR,
+];
+
+for (const dir of dirs) {
+try {
+if (!existsSync(dir)) continue;
+for (const entry of readdirSync(dir)) {
+const entryPath = join(dir, entry);
+try {
+if (statSync(entryPath).isDirectory() && existsSync(join(entryPath, "SKILL.md"))) {
+  discovered.set(entry, join(entryPath, "SKILL.md"));
+} else if (entry.endsWith(".md") || entry.endsWith(".txt")) {
+  discovered.set(entry.replace(/\.(md|txt)$/, ""), entryPath);
+}
+} catch (error) {
+logDiscoveryError(`Failed to inspect inline skill entry ${entryPath}`, error);
+}
+}
+} catch (error) {
+logDiscoveryError(`Failed to scan inline skills dir ${dir}`, error);
+}
+}
+availableSkills = discovered;
+}
+
+/**
+ * Vind alle code block ranges om false positives te voorkomen
+ */
+function findExcludedRanges(text: string): Array<[number, number]> {
+const ranges: Array<[number, number]> = [];
+const fenceRe = /```[\s\S]*?```/g;
+const inlineRe = /`[^`\n]*`/g;
+let m: RegExpExecArray | null;
+while ((m = fenceRe.exec(text))) ranges.push([m.index, m.index + m[0].length]);
+while ((m = inlineRe.exec(text))) ranges.push([m.index, m.index + m[0].length]);
+return ranges;
+}
+
+function isExcluded(index: number, ranges: Array<[number, number]>): boolean {
+return ranges.some(([start, end]) => index >= start && index < end);
+}
+
+/**
+ * Expandeer alle inline triggers (/command en $skill) in de tekst
+ */
+export function expandInlineTriggers(text: string): string {
+discoverSkills();
+
+// Pattern voor zowel /command als $skill
+const TRIGGER_REGEX = /(\/|\$)([a-zA-Z0-9_-]+)/g;
+const excluded = findExcludedRanges(text);
+
+const matches: Array<{ start: number; end: number; full: string; name: string }> = [];
+let match: RegExpExecArray | null;
+
+TRIGGER_REGEX.lastIndex = 0;
+while ((match = TRIGGER_REGEX.exec(text)) !== null) {
+// Skip als binnen code block
+if (isExcluded(match.index, excluded)) continue;
+
+const name = match[2];
+
+// Alleen bekende skills expanden
+if (!availableSkills!.has(name)) continue;
+
+matches.push({
+start: match.index,
+end: match.index + match[0].length,
+full: match[0],
+name
+});
+}
+
+// Geen matches -> originele tekst teruggeven
+if (matches.length === 0) return text;
+
+// Sorteer op positie en verwijder overlappingen
+matches.sort((a, b) => a.start - b.start);
+const deduped: typeof matches = [];
+let lastEnd = -1;
+for (const m of matches) {
+if (m.start >= lastEnd) {
+deduped.push(m);
+lastEnd = m.end;
+}
+}
+
+// Bouw nieuwe tekst op met expansies
+let result = "";
+let cursor = 0;
+
+for (const m of deduped) {
+result += text.slice(cursor, m.start);
+
+const filePath = availableSkills!.get(m.name)!;
+try {
+const rawContent = readFileSync(filePath, "utf-8");
+const cleanContent = stripFrontmatter(rawContent);
+result += `\n\n${cleanContent}\n\n`;
+} catch (error) {
+logDiscoveryError(`Failed to read inline skill ${filePath}`, error);
+// Bij fout, laat originele trigger staan
+result += m.full;
+}
+
+cursor = m.end;
+}
+
+result += text.slice(cursor);
+return result;
+}
+
+/**
+ * Setup de inline invocation hook
+ */
+export function setupInlineInvocation(pi: ExtensionAPI, rt: RuntimeState): void {
+pi.on("input", async (event: any) => {
+// Alleen interactive input verwerken
+if (event.source !== "interactive") {
+return { action: "continue" };
+}
+
+const originalText = event.text;
+const expandedText = expandInlineTriggers(originalText);
+
+// Alleen transformeren als er iets veranderd is
+if (expandedText !== originalText) {
+return { 
+action: "transform", 
+text: expandedText 
+};
+}
+
+return { action: "continue" };
+});
+}

package/src/extension/skills/ook.md

@@ -0,0 +1,6 @@
+---
+name: ook
+description: Ook skill voor tests
+---
+
+Dit is de content van de ook skill.

package/src/extension/skills/test.md

@@ -0,0 +1,6 @@
+---
+name: test
+description: Test skill voor unit tests
+---
+
+Dit is een test skill content die wordt gebruikt voor het testen van inline invocation.

package/src/extension/stale-context.ts

@@ -0,0 +1,10 @@
+// Leaf module: stable predicate used by session-lifecycle and queue-integration
+// without creating a circular import through session-lifecycle.
+
+export function isStaleExtensionContextError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    (error.message.includes("This extension instance is stale") ||
+      error.message.includes("This extension ctx is stale"))
+  );
+}

package/src/extension/stash-history.ts

@@ -0,0 +1,103 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+
+import { truncateToWidth } from "@earendil-works/pi-tui";
+
+import { getAgentPath } from "../paths/agent-dirs.ts";
+import { isRecord } from "./settings-io.ts";
+import { hasNonWhitespaceText } from "./prompt-history.ts";
+import { STASH_HISTORY_LIMIT } from "./constants.ts";
+
+export function getStashHistoryPath(): string {
+  return getAgentPath("powerline-footer", "stash-history.json");
+}
+
+export function normalizeStashHistoryEntries(value: unknown): string[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  const history: string[] = [];
+  for (const entry of value) {
+    if (typeof entry !== "string") {
+      continue;
+    }
+
+    if (!hasNonWhitespaceText(entry)) {
+      continue;
+    }
+
+    if (history[history.length - 1] === entry) {
+      continue;
+    }
+
+    history.push(entry);
+    if (history.length >= STASH_HISTORY_LIMIT) {
+      break;
+    }
+  }
+
+  return history;
+}
+
+export function readPersistedStashHistory(): string[] {
+  const stashHistoryPath = getStashHistoryPath();
+
+  try {
+    if (!existsSync(stashHistoryPath)) {
+      return [];
+    }
+
+    const parsed = JSON.parse(readFileSync(stashHistoryPath, "utf-8"));
+    if (!isRecord(parsed)) {
+      console.debug(
+        `[powerline-footer] Ignoring invalid stash history at ${stashHistoryPath}`,
+      );
+      return [];
+    }
+
+    return normalizeStashHistoryEntries(parsed.history);
+  } catch (error) {
+    console.debug(
+      `[powerline-footer] Failed to read stash history from ${stashHistoryPath}:`,
+      error,
+    );
+    return [];
+  }
+}
+
+export function persistStashHistory(history: string[]): void {
+  const stashHistoryPath = getStashHistoryPath();
+  const payload = {
+    version: 1,
+    history: history.slice(0, STASH_HISTORY_LIMIT),
+  };
+
+  try {
+    mkdirSync(dirname(stashHistoryPath), { recursive: true });
+    writeFileSync(stashHistoryPath, JSON.stringify(payload, null, 2) + "\n");
+  } catch (error) {
+    console.debug(
+      `[powerline-footer] Failed to persist stash history to ${stashHistoryPath}:`,
+      error,
+    );
+  }
+}
+
+export function pushStashHistory(history: string[], text: string): boolean {
+  if (!hasNonWhitespaceText(text)) return false;
+  if (history[0] === text) return false;
+
+  history.unshift(text);
+  if (history.length > STASH_HISTORY_LIMIT) {
+    history.length = STASH_HISTORY_LIMIT;
+  }
+
+  return true;
+}
+
+export function buildStashPreview(text: string, maxWidth: number): string {
+  const compact = text.replace(/\s+/g, " ").trim();
+  if (!compact) return "(empty)";
+  return truncateToWidth(compact, maxWidth, "…");
+}