@chankov/agent-skills 0.1.0

package/.pi/harnesses/purpose-gate/index.ts

@@ -0,0 +1,82 @@
+/**
+ * Purpose Gate — Forces the engineer to declare intent before working
+ *
+ * On session start, immediately asks "What is the purpose of this agent?"
+ * via a text input dialog. A persistent widget shows the purpose for the
+ * rest of the session, keeping focus. Blocks all prompts until answered.
+ *
+ * Usage: pi -e extensions/purpose-gate.ts
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Text, truncateToWidth } from "@mariozechner/pi-tui";
+
+// synthwave: bgWarm #4a1e6a → rgb(74,30,106)
+function bg(s: string): string {
+	return `\x1b[48;2;74;30;106m${s}\x1b[49m`;
+}
+
+// synthwave: pink #ff7edb
+function pink(s: string): string {
+	return `\x1b[38;2;255;126;219m${s}\x1b[39m`;
+}
+
+// synthwave: cyan #36f9f6
+function cyan(s: string): string {
+	return `\x1b[38;2;54;249;246m${s}\x1b[39m`;
+}
+
+function bold(s: string): string {
+	return `\x1b[1m${s}\x1b[22m`;
+}
+
+export default function (pi: ExtensionAPI) {
+	let purpose: string | undefined;
+
+	async function askForPurpose(ctx: any) {
+		while (!purpose) {
+			const answer = await ctx.ui.input(
+				"What is the purpose of this agent?",
+				"e.g. Refactor the auth module to use JWT"
+			);
+
+			if (answer && answer.trim()) {
+				purpose = answer.trim();
+			} else {
+				ctx.ui.notify("Purpose is required.", "warning");
+			}
+		}
+
+		ctx.ui.setWidget("purpose", () => {
+			return {
+				render(width: number): string[] {
+					const pad = bg(" ".repeat(width));
+					const label = pink(bold("  PURPOSE: "));
+					const msg = cyan(bold(purpose!));
+					const content = bg(truncateToWidth(label + msg + " ".repeat(width), width, ""));
+					return [pad, content, pad];
+				},
+				invalidate() {},
+			};
+		});
+	}
+
+	pi.on("session_start", async (_event, ctx) => {
+		void askForPurpose(ctx);
+	});
+
+	pi.on("before_agent_start", async (event) => {
+		if (!purpose) return;
+		return {
+			systemPrompt: event.systemPrompt + `\n\n<purpose>\nYour singular purpose this session: ${purpose}\nStay focused on this goal. If a request drifts from this purpose, gently remind the user.\n</purpose>`,
+		};
+	});
+
+	pi.on("input", async (_event, ctx) => {
+		if (!purpose) {
+			ctx.ui.notify("Set a purpose first.", "warning");
+			return { action: "handled" as const };
+		}
+		return { action: "continue" as const };
+	});
+}

package/.pi/harnesses/purpose-gate/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "agent-skills-pi-purpose-gate",
+  "private": true,
+  "type": "module",
+  "main": "index.ts"
+}

package/.pi/harnesses/session-replay/README.md

@@ -0,0 +1,28 @@
+# session-replay
+
+Scrollable timeline overlay of session history.
+
+> Ported from [`pi-vs-claude-code`](https://github.com/disler/pi-vs-claude-code) by [disler](https://github.com/disler) (MIT). See the [extension catalog](../../../docs/pi-extensions.md).
+
+## What it does
+
+Adds a `/replay` overlay that renders the current session as a scrollable timeline of
+user, assistant, and tool entries — each with timestamps and elapsed-time deltas. Useful
+for reviewing what happened in a long session without scrolling the live transcript.
+
+## Commands & tools
+
+- `/replay` — open the timeline overlay
+- Inside the overlay: `↑`/`↓` to move, `Enter` to expand an entry, `Esc` to close
+
+## Usage
+
+```bash
+pi -e .pi/harnesses/session-replay/index.ts
+```
+
+## Upstream changes
+
+- Theme integration removed — the `themeMap.ts` import and the `applyExtensionDefaults()`
+  call were stripped (this repo does not ship pi themes). The overlay renders against
+  pi's active theme.

package/.pi/harnesses/session-replay/index.ts

@@ -0,0 +1,214 @@
+import { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { 
+  Box, Text, Markdown, Container, Spacer, 
+  matchesKey, Key, truncateToWidth, getMarkdownTheme 
+} from "@mariozechner/pi-tui";
+import { DynamicBorder, getMarkdownTheme as getPiMdTheme } from "@mariozechner/pi-coding-agent";
+
+// Minimal shim for timestamp handling if not directly in Message objects
+function formatTime(date: Date): string {
+    return date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', second: '2-digit' });
+}
+
+function getElapsedTime(start: Date, end: Date): string {
+    const diffMs = end.getTime() - start.getTime();
+    const diffSec = Math.floor(diffMs / 1000);
+    if (diffSec < 60) return `${diffSec}s`;
+    const diffMin = Math.floor(diffSec / 60);
+    return `${diffMin}m ${diffSec % 60}s`;
+}
+
+interface HistoryItem {
+    type: 'user' | 'assistant' | 'tool';
+    title: string;
+    content: string;
+    timestamp: Date;
+    elapsed?: string;
+}
+
+class SessionReplayUI {
+    private selectedIndex = 0;
+    private expandedIndex: number | null = null;
+    private scrollOffset = 0;
+    
+    constructor(
+        private items: HistoryItem[],
+        private onDone: () => void
+    ) {
+        // Start selected at the bottom (most recent)
+        this.selectedIndex = Math.max(0, items.length - 1);
+        this.ensureVisible(20); // rough height estimate
+    }
+
+    handleInput(data: string, tui: any): void {
+        if (matchesKey(data, Key.up)) {
+            this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+        } else if (matchesKey(data, Key.down)) {
+            this.selectedIndex = Math.min(this.items.length - 1, this.selectedIndex + 1);
+        } else if (matchesKey(data, Key.enter)) {
+            this.expandedIndex = this.expandedIndex === this.selectedIndex ? null : this.selectedIndex;
+        } else if (matchesKey(data, Key.escape)) {
+            this.onDone();
+            return;
+        }
+        tui.requestRender();
+    }
+
+    private ensureVisible(height: number) {
+        // Simple scroll window logic
+        const pageSize = Math.floor(height / 3); // Approx items per page
+        if (this.selectedIndex < this.scrollOffset) {
+            this.scrollOffset = this.selectedIndex;
+        } else if (this.selectedIndex >= this.scrollOffset + pageSize) {
+            this.scrollOffset = this.selectedIndex - pageSize + 1;
+        }
+    }
+
+    render(width: number, height: number, theme: any): string[] {
+        this.ensureVisible(height);
+        
+        const container = new Container();
+        const mdTheme = getPiMdTheme();
+
+        // Header
+        container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+        container.addChild(new Text(`${theme.fg("accent", theme.bold(" SESSION REPLAY"))} ${theme.fg("dim", "|")} ${theme.fg("success", this.items.length.toString())} entries`, 1, 0));
+        container.addChild(new Spacer(1));
+
+        // Calculate visible range
+        const visibleItems = this.items.slice(this.scrollOffset);
+
+        visibleItems.forEach((item, idx) => {
+            const absoluteIndex = idx + this.scrollOffset;
+            const isSelected = absoluteIndex === this.selectedIndex;
+            const isExpanded = absoluteIndex === this.expandedIndex;
+            
+            const cardBox = new Box(1, 0, (s) => isSelected ? theme.bg("selectedBg", s) : s);
+            
+            // Icon and Title
+            let icon = "○";
+            let color = "dim";
+            if (item.type === 'user') { icon = "👤"; color = "success"; }
+            else if (item.type === 'assistant') { icon = "🤖"; color = "accent"; }
+            else if (item.type === 'tool') { icon = "🛠️"; color = "warning"; }
+
+            const timeStr = theme.fg("success", `[${formatTime(item.timestamp)}]`);
+            const elapsedStr = item.elapsed ? theme.fg("dim", ` (+${item.elapsed})`) : "";
+            
+            const titleLine = `${theme.fg(color, icon)} ${theme.bold(item.title)} ${timeStr}${elapsedStr}`;
+            cardBox.addChild(new Text(titleLine, 0, 0));
+
+            if (isExpanded) {
+                cardBox.addChild(new Spacer(1));
+                cardBox.addChild(new Markdown(item.content, 2, 0, mdTheme));
+            } else {
+                // Truncated preview
+                const preview = item.content.replace(/\n/g, ' ').substring(0, width - 10);
+                cardBox.addChild(new Text(theme.fg("dim", "  " + preview + "..."), 0, 0));
+            }
+
+            container.addChild(cardBox);
+            // Don't add too many spacers if we have many items
+            if (visibleItems.length < 15) container.addChild(new Spacer(1));
+        });
+
+        // Footer
+        container.addChild(new Spacer(1));
+        container.addChild(new Text(theme.fg("dim", " ↑/↓ Navigate • Enter Expand • Esc Close"), 1, 0));
+        container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+
+        return container.render(width);
+    }
+}
+
+function extractContent(entry: any): string {
+    const msg = entry.message;
+    if (!msg) return "";
+    const content = msg.content;
+    if (!content) return "";
+    if (typeof content === "string") return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((c: any) => {
+                if (c.type === "text") return c.text || "";
+                if (c.type === "toolCall") return `Tool: ${c.name}(${JSON.stringify(c.arguments).slice(0, 200)})`;
+                return "";
+            })
+            .filter(Boolean)
+            .join("\n");
+    }
+    return JSON.stringify(content).slice(0, 500);
+}
+
+export default function(pi: ExtensionAPI) {
+    pi.registerCommand("replay", {
+        description: "Show a scrollable timeline of the current session",
+        handler: async (args, ctx) => {
+            const branch = ctx.sessionManager.getBranch();
+            const items: HistoryItem[] = [];
+
+            let prevTime: Date | null = null;
+
+            for (const entry of branch) {
+                if (entry.type !== "message") continue;
+                const msg = entry.message;
+                if (!msg) continue;
+
+                const ts = msg.timestamp ? new Date(msg.timestamp) : new Date();
+                const elapsed = prevTime ? getElapsedTime(prevTime, ts) : undefined;
+                prevTime = ts;
+
+                const role = msg.role;
+                const text = extractContent(entry);
+                if (!text) continue;
+
+                if (role === "user") {
+                    items.push({
+                        type: "user",
+                        title: "User Prompt",
+                        content: text,
+                        timestamp: ts,
+                        elapsed,
+                    });
+                } else if (role === "assistant") {
+                    items.push({
+                        type: "assistant",
+                        title: "Assistant",
+                        content: text,
+                        timestamp: ts,
+                        elapsed,
+                    });
+                } else if (role === "toolResult") {
+                    const toolName = (msg as any).toolName || "tool";
+                    items.push({
+                        type: "tool",
+                        title: `Tool: ${toolName}`,
+                        content: text,
+                        timestamp: ts,
+                        elapsed,
+                    });
+                }
+            }
+
+            if (items.length === 0) {
+                ctx.ui.notify("No session history found.", "warning");
+                return;
+            }
+
+            await ctx.ui.custom((tui, theme, kb, done) => {
+                const component = new SessionReplayUI(items, () => done(undefined));
+                return {
+                    render: (w) => component.render(w, 30, theme),
+                    handleInput: (data) => component.handleInput(data, tui),
+                    invalidate: () => {},
+                };
+            }, {
+                overlay: true,
+                overlayOptions: { width: "80%", anchor: "center" },
+            });
+        },
+    });
+
+    pi.on("session_start", async (_event, ctx) => {
+    });
+}

package/.pi/harnesses/session-replay/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "agent-skills-pi-session-replay",
+  "private": true,
+  "type": "module",
+  "main": "index.ts"
+}

package/.pi/harnesses/subagent-widget/README.md

@@ -0,0 +1,36 @@
+# subagent-widget
+
+Background subagents with stacking live widgets.
+
+> Ported from [`pi-vs-claude-code`](https://github.com/disler/pi-vs-claude-code) by [disler](https://github.com/disler) (MIT). See the [extension catalog](../../../docs/pi-extensions.md).
+
+## What it does
+
+`/sub <task>` spawns a background pi subagent with its own persistent session and a live
+widget that streams its progress. Multiple subagents stack as separate widgets, and each
+can be resumed with a follow-up via `/subcont`.
+
+## Commands & tools
+
+- `/sub <task>` — spawn a new background subagent
+- `/subcont <n> <task>` — continue subagent #n's conversation with a new prompt
+- `/subrm <n>` — remove subagent #n's widget
+- `/subclear` — clear all subagent widgets
+
+## Usage
+
+```bash
+pi -e .pi/harnesses/subagent-widget/index.ts
+```
+
+Then, for example:
+
+```
+/sub list files and summarize
+/subcont 1 now write tests for it
+```
+
+## Upstream changes
+
+- Theme integration removed — the `themeMap.ts` import and the `applyExtensionDefaults()`
+  call were stripped (this repo does not ship pi themes).