@groeponline/pi-wishcraft 0.17.3

package/src/extension/queue-commands.ts

@@ -0,0 +1,245 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import {
+  captureIdeaFromText,
+  deliverQueueItem,
+  findNextIdea,
+  openQueuePicker,
+  requestQueueRender,
+  resolveCommandTarget,
+  sendIdeaIssueHandoffById,
+  sendOrRetryQueueItem,
+} from "./queue-integration.ts";
+import { getCurrentEditorText } from "./shortcuts-router.ts";
+import { getQueueContext } from "./queue-context.ts";
+import type { RuntimeState } from "./types.ts";
+
+export function registerQueueCommands(
+  pi: ExtensionAPI,
+  rt: RuntimeState,
+): void {
+  pi.registerCommand("idea", {
+    description:
+      "Capture an idea without interrupting the current agent. Usage: /idea [@alias|@global|@current] <text> | /idea issue [id]",
+    handler: async (args, ctx) => {
+      rt.currentCtx = ctx;
+      const trimmedArgs = args.trim();
+      const [action, id] = trimmedArgs.split(/\s+/).filter(Boolean);
+      if (action === "issue") {
+        sendIdeaIssueHandoffById(pi, rt, ctx, id);
+        return;
+      }
+
+      const raw =
+        trimmedArgs || getCurrentEditorText(ctx, rt.currentEditor).trim();
+      if (!raw) {
+        ctx.ui.notify(
+          "Usage: /idea [@alias|@global|@current] <text> | /idea issue [id]",
+          "info",
+        );
+        return;
+      }
+
+      try {
+        const item = captureIdeaFromText(rt, ctx, raw);
+        if (item && !trimmedArgs) {
+          ctx.ui.setEditorText("");
+        }
+      } catch (error) {
+        ctx.ui.notify(
+          error instanceof Error ? error.message : String(error),
+          "error",
+        );
+      }
+    },
+  });
+
+  pi.registerCommand("ideas", {
+    description:
+      "Review or send captured ideas. Usage: /ideas next | /ideas issue [id] | /ideas [send|retry|clear|edit] <id>",
+    handler: async (args, ctx) => {
+      rt.currentCtx = ctx;
+      const parts = args.trim().split(/\s+/).filter(Boolean);
+      const action = parts[0];
+      const id = parts[1];
+
+      if (!action) {
+        await openQueuePicker(pi, rt, ctx, "ideas");
+        return;
+      }
+
+      if (action === "next") {
+        const item = findNextIdea(rt, ctx);
+        if (!item) {
+          ctx.ui.notify("No ideas captured", "info");
+          return;
+        }
+        const updated = rt.queueStore.update(item.id, {
+          status: "queued",
+          target: { kind: "current-session" },
+          error: undefined,
+        });
+        if (updated) deliverQueueItem(pi, rt, ctx, updated);
+        return;
+      }
+
+      if (action === "issue") {
+        sendIdeaIssueHandoffById(pi, rt, ctx, id);
+        return;
+      }
+
+      if (!id) {
+        ctx.ui.notify(
+          "Usage: /ideas next | /ideas issue [id] | /ideas [send|retry|clear|edit] <id>",
+          "info",
+        );
+        return;
+      }
+
+      const item = rt.queueStore.get(id);
+      if (!item || item.intent !== "idea") {
+        ctx.ui.notify(`No unique idea matches ${id}`, "warning");
+        return;
+      }
+
+      if (action === "send" || action === "retry") {
+        const updated = rt.queueStore.update(item.id, {
+          status: "queued",
+          target: { kind: "current-session" },
+          error: undefined,
+        });
+        if (updated) deliverQueueItem(pi, rt, ctx, updated);
+        return;
+      }
+
+      if (action === "edit") {
+        ctx.ui.setEditorText(item.text);
+        rt.queueStore.clear(item.id);
+        requestQueueRender(rt);
+        return;
+      }
+
+      if (action === "clear") {
+        rt.queueStore.clear(item.id);
+        ctx.ui.notify(`Cleared idea ${item.id}`, "info");
+        requestQueueRender(rt);
+        return;
+      }
+
+      ctx.ui.notify(
+        "Usage: /ideas next | /ideas issue [id] | /ideas [send|retry|clear|edit] <id>",
+        "info",
+      );
+    },
+  });
+
+  pi.registerCommand("queue", {
+    description: "Manage Powerline queued prompts and project aliases",
+    handler: async (args, ctx) => {
+      rt.currentCtx = ctx;
+      const parts = args.trim().split(/\s+/).filter(Boolean);
+      const action = parts[0];
+
+      if (!action) {
+        await openQueuePicker(pi, rt, ctx, "queue");
+        return;
+      }
+
+      if (action === "alias") {
+        const alias = parts[1];
+        const aliasPath = parts.slice(2).join(" ") || ctx.cwd || process.cwd();
+        if (!alias) {
+          ctx.ui.notify("Usage: /queue alias <name> [path]", "info");
+          return;
+        }
+        try {
+          rt.queueStore.setAlias(alias, aliasPath);
+          ctx.ui.notify(`Alias @${alias} → ${aliasPath}`, "info");
+        } catch (error) {
+          ctx.ui.notify(
+            error instanceof Error ? error.message : String(error),
+            "error",
+          );
+        }
+        return;
+      }
+
+      if (action === "send" || action === "retry") {
+        const id = parts[1];
+        if (!id) {
+          const item = rt.queueStore.queuedDeliveryItems(
+            getQueueContext(ctx),
+          )[0];
+          if (!item) {
+            ctx.ui.notify("No queued item to send", "info");
+            return;
+          }
+          sendOrRetryQueueItem(pi, rt, ctx, item.id);
+          return;
+        }
+        sendOrRetryQueueItem(pi, rt, ctx, id);
+        return;
+      }
+
+      if (action === "clear") {
+        const id = parts[1];
+        if (id === "all") {
+          const active = rt.queueStore
+            .activeItems(getQueueContext(ctx))
+            .filter((item) => item.intent !== "idea");
+          for (const item of active) rt.queueStore.clear(item.id);
+          ctx.ui.notify(
+            `Cleared ${active.length} queued item${active.length === 1 ? "" : "s"}`,
+            "info",
+          );
+          requestQueueRender(rt);
+          return;
+        }
+        if (!id) {
+          ctx.ui.notify("Usage: /queue clear <id|all>", "info");
+          return;
+        }
+        const item = rt.queueStore.get(id);
+        if (!item || item.intent === "idea") {
+          ctx.ui.notify(`No unique queued item matches ${id}`, "warning");
+          return;
+        }
+        rt.queueStore.clear(item.id);
+        ctx.ui.notify(`Cleared ${item.id}`, "info");
+        requestQueueRender(rt);
+        return;
+      }
+
+      if (action === "target") {
+        const id = parts[1];
+        const spec = parts[2];
+        if (!id || !spec) {
+          ctx.ui.notify(
+            "Usage: /queue target <id> @alias|global|current",
+            "info",
+          );
+          return;
+        }
+        const item = rt.queueStore.get(id);
+        if (!item) {
+          ctx.ui.notify(`No unique queue item matches ${id}`, "warning");
+          return;
+        }
+        try {
+          const target = resolveCommandTarget(rt, ctx, spec);
+          rt.queueStore.update(item.id, { target });
+          ctx.ui.notify(`Retargeted ${item.id}`, "info");
+          requestQueueRender(rt);
+        } catch (error) {
+          ctx.ui.notify(
+            error instanceof Error ? error.message : String(error),
+            "error",
+          );
+        }
+        return;
+      }
+
+      ctx.ui.notify("Usage: /queue [send|retry|clear|target|alias]", "info");
+    },
+  });
+}

package/src/extension/queue-context.ts

@@ -0,0 +1,12 @@
+import { currentQueueContext } from "../../queue/store.ts";
+
+export function getQueueSessionId(ctx: any): string | undefined {
+  const sessionId = ctx.sessionManager?.getSessionId?.();
+  return typeof sessionId === "string" && sessionId.trim()
+    ? sessionId
+    : undefined;
+}
+
+export function getQueueContext(ctx: any) {
+  return currentQueueContext(ctx.cwd ?? process.cwd(), getQueueSessionId(ctx));
+}

package/src/extension/queue-integration.ts

@@ -0,0 +1,434 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { SelectItem } from "@earendil-works/pi-tui";
+
+import {
+  formatIdeaIssuePrompt,
+  formatQueueDeliveryText,
+  parseTargetPrefix,
+  targetForIdea,
+} from "../../queue/store.ts";
+import type {
+  PowerlineQueueItem,
+  QueueIntent,
+  QueueTarget,
+} from "../../queue/types.ts";
+import { requestImmediateStatusRender } from "./segment-context.ts";
+import { buildStashPreview } from "./stash-history.ts";
+import { showSelectOverlay } from "./menu-views.ts";
+import { getQueueContext } from "./queue-context.ts";
+import { isStaleExtensionContextError } from "./stale-context.ts";
+import { config } from "./state.ts";
+import type { RuntimeState } from "./types.ts";
+
+export function requestQueueRender(rt: RuntimeState): void {
+  requestImmediateStatusRender(rt, { deferDuringTyping: false });
+}
+
+export function queueItemLabel(item: PowerlineQueueItem): string {
+  const status =
+    item.status === "queued" ? item.intent : `${item.intent}/${item.status}`;
+  return `${item.id} ${status} ${buildStashPreview(item.text, 56)}`;
+}
+
+export function queueItemDescription(item: PowerlineQueueItem): string {
+  if (item.target.kind === "global") return "global";
+  if (item.target.kind === "current-session") return "current session";
+  return item.target.alias ? `@${item.target.alias}` : item.target.cwd;
+}
+
+export function captureQueueItem(
+  rt: RuntimeState,
+  ctx: any,
+  text: string,
+  intent: QueueIntent,
+  target: QueueTarget,
+): PowerlineQueueItem {
+  const item = rt.queueStore.add({
+    text,
+    intent,
+    target,
+    source: getQueueContext(ctx),
+  });
+  requestQueueRender(rt);
+  return item;
+}
+
+export function captureIdeaFromParsedInput(
+  rt: RuntimeState,
+  ctx: any,
+  parsed: { target: string | null; text: string },
+): PowerlineQueueItem | null {
+  const trimmed = parsed.text.trim();
+  if (!trimmed) {
+    ctx.ui.notify("Nothing to capture", "info");
+    return null;
+  }
+
+  const target = targetForIdea(
+    parsed.target,
+    rt.queueStore,
+    ctx.cwd ?? process.cwd(),
+  );
+  const item = captureQueueItem(rt, ctx, trimmed, "idea", target);
+  ctx.ui.notify(`Idea saved (${item.id}) — /ideas to review`, "info");
+  return item;
+}
+
+export function captureIdeaFromText(
+  rt: RuntimeState,
+  ctx: any,
+  text: string,
+): PowerlineQueueItem | null {
+  return captureIdeaFromParsedInput(rt, ctx, parseTargetPrefix(text));
+}
+
+export function captureCurrentProjectIdea(
+  rt: RuntimeState,
+  ctx: any,
+  text: string,
+): PowerlineQueueItem | null {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    ctx.ui.notify("Nothing to capture", "info");
+    return null;
+  }
+
+  const item = captureQueueItem(rt, ctx, trimmed, "idea", {
+    kind: "project",
+    cwd: ctx.cwd ?? process.cwd(),
+  });
+  ctx.ui.notify(`Idea saved (${item.id}) — /ideas to review`, "info");
+  return item;
+}
+
+export function isSigilIdeaDraft(text: string): boolean {
+  const sigil = config.queue.captureSigil;
+  if (sigil === false) return false;
+  const normalizedSigil = sigil.trim();
+  if (!normalizedSigil) return false;
+  const trimmed = text.trimStart();
+  return (
+    trimmed.startsWith(normalizedSigil) &&
+    /^\s/.test(trimmed.slice(normalizedSigil.length))
+  );
+}
+
+export function captureSigilGlyph(): string {
+  const sigil =
+    config.queue.captureSigil === false ? "#" : config.queue.captureSigil;
+  return Array.from(sigil)[0] ?? "#";
+}
+
+export function capturePostCompactPrompt(
+  rt: RuntimeState,
+  ctx: any,
+  text: string,
+): PowerlineQueueItem | null {
+  const trimmed = text.trim();
+  if (!trimmed) return null;
+
+  const item = captureQueueItem(rt, ctx, trimmed, "post-compact", {
+    kind: "current-session",
+  });
+  ctx.ui.notify(`Queued for after compaction (${item.id})`, "info");
+  return item;
+}
+
+export function deliveryModeForItem(
+  ctx: any,
+  item: PowerlineQueueItem,
+): "steer" | "followUp" | undefined {
+  const idle = typeof ctx.isIdle === "function" ? ctx.isIdle() : true;
+  if (idle) return undefined;
+  return item.intent === "steer" ? "steer" : "followUp";
+}
+
+export function deliverQueueItem(
+  pi: ExtensionAPI,
+  rt: RuntimeState,
+  ctx: any,
+  item: PowerlineQueueItem,
+): boolean {
+  if (rt.powerlineCompacting) {
+    rt.queueStore.update(item.id, { status: "queued" });
+    requestQueueRender(rt);
+    return false;
+  }
+
+  rt.queueStore.update(item.id, { status: "delivering", error: undefined });
+  requestQueueRender(rt);
+
+  let sent = false;
+  try {
+    const deliverAs = deliveryModeForItem(ctx, item);
+    const deliveryText = formatQueueDeliveryText(item);
+    if (deliverAs) {
+      pi.sendUserMessage(deliveryText, { deliverAs });
+    } else {
+      pi.sendUserMessage(deliveryText);
+    }
+    sent = true;
+    rt.queueStore.update(item.id, { status: "sent", error: undefined });
+    try {
+      ctx.ui.notify(`Sent queued item ${item.id}`, "info");
+    } catch (error) {
+      if (!isStaleExtensionContextError(error)) throw error;
+    }
+    requestQueueRender(rt);
+    return true;
+  } catch (error) {
+    if (isStaleExtensionContextError(error)) {
+      // The extension context was replaced (reload/session swap) mid-delivery.
+      // Leave the item queued so it can be retried instead of marking it failed.
+      if (!sent) {
+        rt.queueStore.update(item.id, { status: "queued", error: undefined });
+        requestQueueRender(rt);
+      }
+      return false;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    rt.queueStore.update(item.id, { status: "failed", error: message });
+    ctx.ui.notify(`Failed to send ${item.id}: ${message}`, "error");
+    requestQueueRender(rt);
+    return false;
+  }
+}
+
+export function schedulePostCompactionDelivery(
+  pi: ExtensionAPI,
+  rt: RuntimeState,
+  ctx: any,
+): void {
+  if (rt.queueDeliveryTimer) clearTimeout(rt.queueDeliveryTimer);
+  const queueContext = getQueueContext(ctx);
+  const scheduledGeneration = rt.sessionGeneration;
+  rt.queueDeliveryTimer = setTimeout(() => {
+    rt.queueDeliveryTimer = null;
+    if (scheduledGeneration !== rt.sessionGeneration) return;
+    const item = rt.queueStore.queuedDeliveryItems(queueContext, "post-compact")[0];
+    if (!item) return;
+    try {
+      deliverQueueItem(pi, rt, ctx, item);
+    } catch (error) {
+      if (!isStaleExtensionContextError(error)) throw error;
+    }
+  }, 50);
+}
+
+export function blockPostCompactionQueue(
+  rt: RuntimeState,
+  ctx: any,
+  errorMessage: string,
+): void {
+  const items = rt.queueStore.queuedDeliveryItems(
+    getQueueContext(ctx),
+    "post-compact",
+  );
+  for (const item of items) {
+    rt.queueStore.update(item.id, { status: "blocked", error: errorMessage });
+  }
+  if (items.length > 0) {
+    ctx.ui.notify(
+      `Kept ${items.length} post-compaction item${items.length === 1 ? "" : "s"} blocked`,
+      "warning",
+    );
+    requestQueueRender(rt);
+  }
+}
+
+export function finishFailedCompaction(
+  rt: RuntimeState,
+  ctx: any,
+  errorMessage: string,
+): void {
+  rt.powerlineCompacting = false;
+  rt.deliverAfterRetrySettles = false;
+  blockPostCompactionQueue(rt, ctx, errorMessage);
+  requestQueueRender(rt);
+}
+
+export async function chooseQueueAction(
+  pi: ExtensionAPI,
+  rt: RuntimeState,
+  ctx: any,
+  item: PowerlineQueueItem,
+): Promise<void> {
+  const actions: SelectItem[] = [
+    {
+      value: "send",
+      label: "Send to current session",
+      description: "Deliver as prompt/follow-up",
+    },
+    {
+      value: "edit",
+      label: "Edit in prompt",
+      description: "Move text into the editor",
+    },
+    {
+      value: "retry",
+      label: "Retry",
+      description: "Mark queued and deliver",
+    },
+    { value: "clear", label: "Clear", description: "Mark item done" },
+    { value: "cancel", label: "Cancel" },
+  ];
+  const selected = await showSelectOverlay(
+    ctx,
+    `Queue item ${item.id}`,
+    buildStashPreview(item.text, 72),
+    actions,
+    actions.length,
+  );
+  if (!selected || selected.value === "cancel") return;
+
+  if (selected.value === "send") {
+    deliverQueueItem(pi, rt, ctx, item);
+    return;
+  }
+
+  if (selected.value === "retry") {
+    const updated = rt.queueStore.update(item.id, {
+      status: "queued",
+      error: undefined,
+    });
+    if (updated) deliverQueueItem(pi, rt, ctx, updated);
+    return;
+  }
+
+  if (selected.value === "edit") {
+    ctx.ui.setEditorText(item.text);
+    rt.queueStore.clear(item.id);
+    requestQueueRender(rt);
+    return;
+  }
+
+  if (selected.value === "clear") {
+    rt.queueStore.clear(item.id);
+    ctx.ui.notify(`Cleared ${item.id}`, "info");
+    requestQueueRender(rt);
+  }
+}
+
+export async function openQueuePicker(
+  pi: ExtensionAPI,
+  rt: RuntimeState,
+  ctx: any,
+  mode: "ideas" | "queue",
+): Promise<void> {
+  const active = rt.queueStore
+    .activeItems(getQueueContext(ctx))
+    .filter((item) =>
+      mode === "ideas" ? item.intent === "idea" : item.intent !== "idea",
+    );
+  if (active.length === 0) {
+    ctx.ui.notify(
+      mode === "ideas" ? "No ideas captured" : "No queued items",
+      "info",
+    );
+    return;
+  }
+
+  const items: SelectItem[] = active.map((item) => ({
+    value: item.id,
+    label: queueItemLabel(item),
+    description: queueItemDescription(item),
+  }));
+  const selected = await showSelectOverlay(
+    ctx,
+    mode === "ideas" ? "Powerline ideas" : "Powerline queue",
+    "↑↓ navigate • enter manage • esc cancel",
+    items,
+    Math.min(active.length, 12),
+  );
+  if (!selected) return;
+
+  const item = active.find((candidate) => candidate.id === selected.value);
+  if (item) await chooseQueueAction(pi, rt, ctx, item);
+}
+
+export function resolveCommandTarget(
+  rt: RuntimeState,
+  ctx: any,
+  spec: string,
+): QueueTarget {
+  const normalized = spec.trim().replace(/^@/, "");
+  return targetForIdea(
+    normalized || null,
+    rt.queueStore,
+    ctx.cwd ?? process.cwd(),
+  );
+}
+
+export function sendOrRetryQueueItem(
+  pi: ExtensionAPI,
+  rt: RuntimeState,
+  ctx: any,
+  idPrefix: string,
+): void {
+  const item = rt.queueStore.get(idPrefix);
+  if (!item) {
+    ctx.ui.notify(`No unique queue item matches ${idPrefix}`, "warning");
+    return;
+  }
+  const updated = rt.queueStore.update(item.id, {
+    status: "queued",
+    error: undefined,
+  });
+  if (updated) deliverQueueItem(pi, rt, ctx, updated);
+}
+
+export function findNextIdea(
+  rt: RuntimeState,
+  ctx: any,
+): PowerlineQueueItem | null {
+  return (
+    rt.queueStore
+      .activeItems(getQueueContext(ctx))
+      .find((candidate) => candidate.intent === "idea") ?? null
+  );
+}
+
+export function sendIdeaIssueHandoff(
+  pi: ExtensionAPI,
+  rt: RuntimeState,
+  ctx: any,
+  item: PowerlineQueueItem,
+): void {
+  rt.queueStore.update(item.id, { status: "delivering", error: undefined });
+  requestQueueRender(rt);
+
+  try {
+    const deliverAs = deliveryModeForItem(ctx, item);
+    const issuePrompt = formatIdeaIssuePrompt(item);
+    if (deliverAs) {
+      pi.sendUserMessage(issuePrompt, { deliverAs });
+    } else {
+      pi.sendUserMessage(issuePrompt);
+    }
+    rt.queueStore.update(item.id, { status: "sent", error: undefined });
+    ctx.ui.notify(`Sent idea ${item.id} for issue triage`, "info");
+    requestQueueRender(rt);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    rt.queueStore.update(item.id, { status: "failed", error: message });
+    ctx.ui.notify(`Failed to send ${item.id}: ${message}`, "error");
+    requestQueueRender(rt);
+  }
+}
+
+export function sendIdeaIssueHandoffById(
+  pi: ExtensionAPI,
+  rt: RuntimeState,
+  ctx: any,
+  id: string | undefined,
+): void {
+  const item = id ? rt.queueStore.get(id) : findNextIdea(rt, ctx);
+  if (!item || item.intent !== "idea") {
+    ctx.ui.notify(
+      id ? `No unique idea matches ${id}` : "No ideas captured",
+      id ? "warning" : "info",
+    );
+    return;
+  }
+  sendIdeaIssueHandoff(pi, rt, ctx, item);
+}