pi-amplike 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pasky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,112 @@
+# pi-amplike
+
+[Pi](https://github.com/badlogic/pi-mono) skills and extensions that give Pi similar capabilities to [Amp Code](https://ampcode.com/) out of the box.
+
+## Features
+
+### Session Management
+- **`/handoff <goal>`** - Create a new focused session based on the current one with context compacted based on a given goal
+- **`session_query`** tool - The agent in the handed off session automatically gets the ability to query the parent session for context, decisions, or code changes
+- Use `/resume` to switch between and navigate handed-off sessions
+
+### Web Access
+- **web-search** - Search the web via Jina Search API
+- **visit-webpage** - Extract webpage content as markdown (using Jina API), or download images
+
+## Installation
+
+### Option A: Install from npm (recommended)
+
+```bash
+mkdir -p ~/.pi/packages
+cd ~/.pi/packages
+npm install pi-amplike
+```
+
+This creates `~/.pi/packages/node_modules/pi-amplike`. Pi will pick it up as a package automatically.
+
+### Option B: Install from git
+
+```bash
+git clone https://github.com/pasky/pi-amplike ~/.pi/packages/pi-amplike
+cd ~/.pi/packages/pi-amplike
+npm install
+```
+
+## Setup
+
+Get a Jina API key for web skills (optional, works with rate limits without it):
+
+```bash
+export JINA_API_KEY="your-key"  # Add to ~/.profile or ~/.zprofile
+```
+
+Get an API key at [jina.ai](https://jina.ai/). Even if you charge only the minimum credit, it's going to last approximately forever.
+
+## Usage
+
+### Session Handoff
+
+When your conversation gets long or you want to branch off to a focused task:
+
+```
+/handoff now implement this for teams as well
+/handoff execute phase one of the plan
+/handoff check other places that need this fix
+```
+
+This creates a new session with:
+- Summarized context from the current conversation
+- List of relevant files
+- Clear task description based on your goal
+- Reference to parent session (for later querying)
+
+### Session Navigation
+
+Use Pi's built-in `/resume` command to switch between sessions, including handed-off sessions. The handoff creates sessions with descriptive names that make them easy to find.
+
+### Querying Past Sessions
+
+The `session_query` tool lets the model look up information from previous sessions. It's automatically used when a handoff includes parent session reference, but can also be invoked directly:
+
+```
+session_query("/path/to/session.jsonl", "What files were modified?")
+session_query("/path/to/session.jsonl", "What approach was chosen?")
+```
+
+### Web Search
+
+```bash
+~/.pi/packages/pi-amplike/skills/web-search/search.py "python async tutorial"
+```
+
+### Visit Webpage
+
+```bash
+~/.pi/packages/pi-amplike/skills/visit-webpage/visit.py https://docs.example.com/api
+```
+
+## Components
+
+| Component | Type | Description |
+|-----------|------|-------------|
+| [handoff](extensions/handoff.ts) | Extension | `/handoff` command for context transfer |
+| [session-query](extensions/session-query.ts) | Extension | `session_query` tool for the model |
+| [session-query](skills/session-query/) | Skill | Instructions for using the session_query tool |
+| [web-search](skills/web-search/) | Skill | Web search via Jina API |
+| [visit-webpage](skills/visit-webpage/) | Skill | Webpage content extraction |
+
+## Why "AmpCode-like"?
+
+Amp Code has excellent session management built-in - you can branch conversations, reference parent context, and navigate session history. This package brings similar workflows to Pi:
+
+- **Context handoff** → Amp's conversation branching
+- **Session querying** → Amp's ability to reference parent context
+
+## Web Skills Origin
+
+The web-search and visit-webpage skills were extracted from [pasky/muaddib](https://github.com/pasky/muaddib). The original implementations have additional features (rate limiting, multiple backends, async execution) that aren't needed for Pi's skill system.
+
+## License
+
+MIT

package/extensions/handoff.ts

@@ -0,0 +1,151 @@
+/**
+ * Handoff extension - transfer context to a new focused session
+ *
+ * Instead of compacting (which is lossy), handoff extracts what matters
+ * for your next task and creates a new session with a generated prompt.
+ *
+ * Usage:
+ *   /handoff now implement this for teams as well
+ *   /handoff execute phase one of the plan
+ *   /handoff check other places that need this fix
+ *
+ * The generated prompt appears as a draft in the editor for review/editing.
+ */
+
+import { complete, type Message } from "@mariozechner/pi-ai";
+import type { ExtensionAPI, SessionEntry } from "@mariozechner/pi-coding-agent";
+import { BorderedLoader, convertToLlm, serializeConversation } from "@mariozechner/pi-coding-agent";
+
+const SYSTEM_PROMPT = `You are a context transfer assistant. Given a conversation history and the user's goal for a new thread, generate a focused prompt that:
+
+1. Summarizes relevant context from the conversation (decisions made, approaches taken, key findings)
+2. Lists any relevant files that were discussed or modified
+3. Clearly states the next task based on the user's goal
+4. Is self-contained - the new thread should be able to proceed without the old conversation
+
+Format your response as a prompt the user can send to start the new thread. Be concise but include all necessary context. Do not include any preamble like "Here's the prompt" - just output the prompt itself.
+
+Example output format:
+## Context
+We've been working on X. Key decisions:
+- Decision 1
+- Decision 2
+
+Files involved:
+- path/to/file1.ts
+- path/to/file2.ts
+
+## Task
+[Clear description of what to do next based on user's goal]`;
+
+export default function (pi: ExtensionAPI) {
+	pi.registerCommand("handoff", {
+		description: "Transfer context to a new focused session",
+		handler: async (args, ctx) => {
+			if (!ctx.hasUI) {
+				ctx.ui.notify("handoff requires interactive mode", "error");
+				return;
+			}
+
+			if (!ctx.model) {
+				ctx.ui.notify("No model selected", "error");
+				return;
+			}
+
+			const goal = args.trim();
+			if (!goal) {
+				ctx.ui.notify("Usage: /handoff <goal for new thread>", "error");
+				return;
+			}
+
+			// Gather conversation context from current branch
+			const branch = ctx.sessionManager.getBranch();
+			const messages = branch
+				.filter((entry): entry is SessionEntry & { type: "message" } => entry.type === "message")
+				.map((entry) => entry.message);
+
+			if (messages.length === 0) {
+				ctx.ui.notify("No conversation to hand off", "error");
+				return;
+			}
+
+			// Convert to LLM format and serialize
+			const llmMessages = convertToLlm(messages);
+			const conversationText = serializeConversation(llmMessages);
+			const currentSessionFile = ctx.sessionManager.getSessionFile();
+
+			// Generate the handoff prompt with loader UI
+			const result = await ctx.ui.custom<string | null>((tui, theme, _kb, done) => {
+				const loader = new BorderedLoader(tui, theme, `Generating handoff prompt...`);
+				loader.onAbort = () => done(null);
+
+				const doGenerate = async () => {
+					const apiKey = await ctx.modelRegistry.getApiKey(ctx.model!);
+
+					const userMessage: Message = {
+						role: "user",
+						content: [
+							{
+								type: "text",
+								text: `## Conversation History\n\n${conversationText}\n\n## User's Goal for New Thread\n\n${goal}`,
+							},
+						],
+						timestamp: Date.now(),
+					};
+
+					const response = await complete(
+						ctx.model!,
+						{ systemPrompt: SYSTEM_PROMPT, messages: [userMessage] },
+						{ apiKey, signal: loader.signal },
+					);
+
+					if (response.stopReason === "aborted") {
+						return null;
+					}
+
+					return response.content
+						.filter((c): c is { type: "text"; text: string } => c.type === "text")
+						.map((c) => c.text)
+						.join("\n");
+				};
+
+				doGenerate()
+					.then(done)
+					.catch((err) => {
+						console.error("Handoff generation failed:", err);
+						done(null);
+					});
+
+				return loader;
+			});
+
+			if (result === null) {
+				ctx.ui.notify("Cancelled", "info");
+				return;
+			}
+
+			// Create new session with parent tracking
+			const newSessionResult = await ctx.newSession({
+				parentSession: currentSessionFile,
+			});
+
+			if (newSessionResult.cancelled) {
+				ctx.ui.notify("New session cancelled", "info");
+				return;
+			}
+
+			// Build the final prompt with user's goal first for easy identification
+			// Format: goal (first line for session preview) → skill → parent ref → context
+			let finalPrompt = result;
+			if (currentSessionFile) {
+				finalPrompt = `${goal}\n\n/skill:session-query\n\n**Parent session:** \`${currentSessionFile}\`\n\n${result}`;
+			} else {
+				// Even without parent session, put goal first
+				finalPrompt = `${goal}\n\n${result}`;
+			}
+
+			// Immediately submit the handoff prompt to start the agent
+			pi.sendUserMessage(finalPrompt);
+		},
+	});
+}

package/extensions/session-query.ts

@@ -0,0 +1,180 @@
+/**
+ * Session Query Extension - Query previous pi sessions
+ *
+ * Provides a tool the model can use to query past sessions for context,
+ * decisions, code changes, or other information.
+ *
+ * Works with handoff: when a handoff prompt includes "Parent session: <path>",
+ * the model can use this tool to look up details from that session.
+ */
+
+import { complete, type Message } from "@mariozechner/pi-ai";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import {
+	SessionManager,
+	convertToLlm,
+	getMarkdownTheme,
+	serializeConversation,
+	type SessionEntry,
+} from "@mariozechner/pi-coding-agent";
+import { Container, Markdown, Spacer, Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+
+const QUERY_SYSTEM_PROMPT = `You are a session context assistant. Given the conversation history from a pi coding session and a question, provide a concise answer based on the session contents.
+
+Focus on:
+- Specific facts, decisions, and outcomes
+- File paths and code changes mentioned
+- Key context the user is asking about
+
+Be concise and direct. If the information isn't in the session, say so.`;
+
+export default function (pi: ExtensionAPI) {
+	pi.registerTool({
+		name: "session_query",
+		label: (params) => `Session Query: ${params.question}`,
+		description:
+			"Query a previous pi session file for context, decisions, or information. Use when you need to look up what happened in a parent session or any other session.",
+		renderResult: (result, _options, theme) => {
+			const container = new Container();
+			
+			if (result.content && result.content[0]?.text) {
+				const text = result.content[0].text;
+				// Parse: **Query:** question\n\n---\n\nanswer
+				const match = text.match(/\*\*Query:\*\* (.+?)\n\n---\n\n([\s\S]+)/);
+				
+				if (match) {
+					const [, query, answer] = match;
+					container.addChild(new Text(theme.bold("Query: ") + theme.fg("accent", query), 0, 0));
+					container.addChild(new Spacer(1));
+					// Render the answer as markdown
+					container.addChild(new Markdown(answer.trim(), 0, 0, getMarkdownTheme(), {
+						color: (text: string) => theme.fg("toolOutput", text),
+					}));
+				} else {
+					// Fallback for other formats (errors, etc)
+					container.addChild(new Text(theme.fg("toolOutput", text), 0, 0));
+				}
+			}
+			
+			return container;
+		},
+		parameters: Type.Object({
+			sessionPath: Type.String({
+				description: "Full path to the session file (e.g., /home/user/.pi/agent/sessions/.../session.jsonl)",
+			}),
+			question: Type.String({
+				description: "What you want to know about that session (e.g., 'What files were modified?' or 'What approach was chosen?')",
+			}),
+		}),
+
+		async execute(toolCallId, params, onUpdate, ctx, signal) {
+			const { sessionPath, question } = params;
+
+			// Helper for error returns
+			const errorResult = (text: string) => ({
+				content: [{ type: "text" as const, text }],
+				details: { error: true },
+			});
+
+			// Validate session path
+			if (!sessionPath.endsWith(".jsonl")) {
+				return errorResult(`Error: Invalid session path. Expected a .jsonl file, got: ${sessionPath}`);
+			}
+
+			// Check if file exists
+			try {
+				const fs = await import("node:fs");
+				if (!fs.existsSync(sessionPath)) {
+					return errorResult(`Error: Session file not found: ${sessionPath}`);
+				}
+			} catch (err) {
+				return errorResult(`Error checking session file: ${err}`);
+			}
+
+			onUpdate?.({
+				content: [
+					{
+						type: "text",
+						text: `Query: ${question}`,
+					},
+				],
+				details: { status: "loading", question },
+			});
+
+			// Load the session
+			let sessionManager: SessionManager;
+			try {
+				sessionManager = SessionManager.open(sessionPath);
+			} catch (err) {
+				return errorResult(`Error loading session: ${err}`);
+			}
+
+			// Get conversation from the session
+			const branch = sessionManager.getBranch();
+			const messages = branch
+				.filter((entry): entry is SessionEntry & { type: "message" } => entry.type === "message")
+				.map((entry) => entry.message);
+
+			if (messages.length === 0) {
+				return {
+					content: [{ type: "text" as const, text: "Session is empty - no messages found." }],
+					details: { empty: true },
+				};
+			}
+
+			// Serialize the conversation
+			const llmMessages = convertToLlm(messages);
+			const conversationText = serializeConversation(llmMessages);
+
+			// Use LLM to answer the question
+			if (!ctx.model) {
+				return errorResult("Error: No model available to analyze the session.");
+			}
+
+			try {
+				const apiKey = await ctx.modelRegistry.getApiKey(ctx.model);
+
+				const userMessage: Message = {
+					role: "user",
+					content: [
+						{
+							type: "text",
+							text: `## Session Conversation\n\n${conversationText}\n\n## Question\n\n${question}`,
+						},
+					],
+					timestamp: Date.now(),
+				};
+
+				const response = await complete(
+					ctx.model,
+					{ systemPrompt: QUERY_SYSTEM_PROMPT, messages: [userMessage] },
+					{ apiKey, signal },
+				);
+
+				if (response.stopReason === "aborted") {
+					return {
+						content: [{ type: "text" as const, text: "Query was cancelled." }],
+						details: { cancelled: true },
+					};
+				}
+
+				const answer = response.content
+					.filter((c): c is { type: "text"; text: string } => c.type === "text")
+					.map((c) => c.text)
+					.join("\n");
+
+				return {
+					content: [{ type: "text" as const, text: `**Query:** ${question}\n\n---\n\n${answer}` }],
+					details: {
+						sessionPath,
+						question,
+						messageCount: messages.length,
+					},
+				};
+			} catch (err) {
+				return errorResult(`Error querying session: ${err}`);
+			}
+		},
+	});
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "pi-amplike",
+  "version": "0.1.0",
+  "description": "Pi skills and extensions that provide Amp Code-like workflows (handoff, session query, web search, visit webpage).",
+  "license": "MIT",
+  "homepage": "https://github.com/pasky/pi-amplike",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pasky/pi-amplike.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pasky/pi-amplike/issues"
+  },
+  "keywords": [
+    "pi",
+    "pi-coding-agent",
+    "agent",
+    "skills",
+    "extensions",
+    "amp",
+    "session",
+    "handoff",
+    "web-search"
+  ],
+  "files": [
+    "extensions/",
+    "skills/",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "skills": [
+      "./skills/visit-webpage",
+      "./skills/web-search",
+      "./skills/session-query"
+    ],
+    "extensions": [
+      "./extensions"
+    ]
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/node": "^25.1.0",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@mariozechner/pi-coding-agent": "^0.50.5",
+    "@mariozechner/pi-tui": "^0.50.5"
+  }
+}

package/skills/session-query/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: session-query
+description: Query previous pi sessions to retrieve context, decisions, code changes, or other information. Use when you need to look up what happened in a parent session or any other session file.
+disable-model-invocation: true
+---
+
+# Session Query
+
+Query pi session files to retrieve context from past conversations.
+
+This skill is automatically invoked in handed-off sessions when you need to look up details from the parent session.
+
+## Usage
+
+Use the `session_query` tool:
+
+```
+session_query(sessionPath, question)
+```
+
+- `sessionPath`: Full path to the session file (provided in the "Parent session:" line)
+- `question`: Specific question about that session (e.g., "What files were modified?" or "What approach was chosen?")
+
+## Examples
+
+```
+session_query("/path/to/session.jsonl", "What files were modified?")
+session_query("/path/to/session.jsonl", "What approach was chosen for authentication?")
+session_query("/path/to/session.jsonl", "Summarize the key decisions made")
+```
+
+The tool loads the session and uses an LLM to answer your question based on its contents. Ask specific questions for best results.

package/skills/visit-webpage/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: visit-webpage
+description: Visit a webpage and extract its content as markdown, or fetch images. Use for reading articles, documentation, or any web page content. Handles both HTML pages (via Jina Reader) and image URLs (downloads and saves locally).
+---
+
+# Visit Webpage
+
+Fetch and extract readable content from web pages as markdown, or download images. Handles JavaScript-rendered content via Jina Reader service.
+
+## Setup
+
+Optionally get a Jina API key for higher rate limits:
+1. Create an account at https://jina.ai/
+2. Get your API key from the dashboard
+3. Add to your shell profile (`~/.profile` or `~/.zprofile` for zsh):
+   ```bash
+   export JINA_API_KEY="your-api-key-here"
+   ```
+
+Without an API key, the service works with rate limits.
+
+## Usage
+
+```bash
+{baseDir}/visit.py <url>
+```
+
+## Examples
+
+```bash
+# Read an article (returns markdown)
+{baseDir}/visit.py https://example.com/article
+
+# Fetch documentation
+{baseDir}/visit.py https://docs.python.org/3/library/asyncio.html
+
+# Download an image (auto-detected by content-type)
+{baseDir}/visit.py https://example.com/image.png
+# Then use read tool to view: read /tmp/visit-image-xxx.png
+```
+
+## Output
+
+For **HTML pages**: Returns markdown content to stdout.
+
+For **images**: Downloads the image to a temp file and prints the path. Use the `read` tool to view it. Supports PNG, JPEG, GIF, and WebP formats.
+
+## Features
+
+- Extracts main content from HTML pages
+- Converts HTML to clean markdown
+- Handles JavaScript-rendered pages via Jina Reader
+- Auto-detects and downloads images to temp files
+- Retries on rate limiting (HTTP 451)
+- 5MB max image size limit
+
+## When to Use
+
+- Reading articles, blog posts, or documentation
+- Extracting content from search results
+- Downloading images from URLs (then use `read` to view)
+- Following links found during web search

package/skills/visit-webpage/visit.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""Visit webpage and extract content as markdown, or download images."""
+
+import os
+import re
+import sys
+import tempfile
+import time
+import urllib.request
+from urllib.error import HTTPError, URLError
+
+MAX_IMAGE_SIZE = 5 * 1024 * 1024  # 5MB
+MAX_CONTENT_LENGTH = 100000  # 100KB text limit
+TIMEOUT = 60
+RETRY_DELAYS = [0, 30, 90]
+
+IMAGE_EXTENSIONS = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+}
+
+
+def get_headers(include_jina_auth: bool = False) -> dict[str, str]:
+    """Build request headers."""
+    headers = {"User-Agent": "pi-skill/1.0"}
+    api_key = os.environ.get("JINA_API_KEY")
+    if include_jina_auth and api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    return headers
+
+
+def check_content_type(url: str) -> str | None:
+    """Check URL content type via HEAD request. Returns content-type or None on error."""
+    req = urllib.request.Request(url, method="HEAD", headers=get_headers())
+    try:
+        with urllib.request.urlopen(req, timeout=TIMEOUT) as response:
+            return response.headers.get("Content-Type", "").lower().split(";")[0]
+    except (HTTPError, URLError):
+        return None
+
+
+def download_image(url: str) -> str:
+    """Download image and save to temp file. Returns file path."""
+    req = urllib.request.Request(url, headers=get_headers())
+    
+    with urllib.request.urlopen(req, timeout=TIMEOUT) as response:
+        content_type = response.headers.get("Content-Type", "").lower().split(";")[0]
+        
+        if content_type not in IMAGE_EXTENSIONS:
+            raise ValueError(f"Unsupported image type: {content_type}")
+        
+        content_length = response.headers.get("Content-Length")
+        if content_length and int(content_length) > MAX_IMAGE_SIZE:
+            raise ValueError(f"Image too large: {content_length} bytes (max {MAX_IMAGE_SIZE})")
+        
+        data = response.read()
+        if len(data) > MAX_IMAGE_SIZE:
+            raise ValueError(f"Image too large: {len(data)} bytes (max {MAX_IMAGE_SIZE})")
+        
+        ext = IMAGE_EXTENSIONS[content_type]
+        
+        # Create temp file with appropriate extension
+        fd, filepath = tempfile.mkstemp(suffix=ext, prefix="visit-image-")
+        os.write(fd, data)
+        os.close(fd)
+        
+        return filepath
+
+
+def fetch_webpage(url: str) -> str:
+    """Fetch webpage content via Jina Reader with retries."""
+    jina_url = f"https://r.jina.ai/{url}"
+    headers = get_headers(include_jina_auth=True)
+    
+    last_error = None
+    for i, delay in enumerate(RETRY_DELAYS):
+        if delay > 0:
+            print(f"Waiting {delay}s before retry {i+1}/{len(RETRY_DELAYS)}...", file=sys.stderr)
+            time.sleep(delay)
+        
+        req = urllib.request.Request(jina_url, headers=headers)
+        try:
+            with urllib.request.urlopen(req, timeout=TIMEOUT) as response:
+                content = response.read().decode("utf-8", errors="replace")
+                
+                # Clean up multiple line breaks
+                content = re.sub(r"\n{3,}", "\n\n", content)
+                
+                # Truncate if too long
+                if len(content) > MAX_CONTENT_LENGTH:
+                    content = content[:MAX_CONTENT_LENGTH] + "\n\n..._Content truncated_..."
+                
+                return content
+                
+        except HTTPError as e:
+            last_error = e
+            if e.code in (451, 500, 502, 503, 504) and i < len(RETRY_DELAYS) - 1:
+                print(f"HTTP {e.code}, will retry...", file=sys.stderr)
+                continue
+            raise
+        except URLError as e:
+            last_error = e
+            if i < len(RETRY_DELAYS) - 1:
+                print(f"Network error: {e.reason}, will retry...", file=sys.stderr)
+                continue
+            raise
+    
+    raise last_error or RuntimeError("Failed after retries")
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: visit.py <url>")
+        print()
+        print("Fetches a webpage and extracts its content as markdown,")
+        print("or downloads images to a temp file.")
+        print()
+        print("Environment:")
+        print("  JINA_API_KEY    Optional. Your Jina API key for higher rate limits.")
+        print()
+        print("Examples:")
+        print("  visit.py https://example.com/article")
+        print("  visit.py https://example.com/image.png")
+        sys.exit(1)
+    
+    url = sys.argv[1]
+    
+    # Validate URL
+    if not url.startswith(("http://", "https://")):
+        print("Error: URL must start with http:// or https://", file=sys.stderr)
+        sys.exit(1)
+    
+    try:
+        # Check content type first
+        content_type = check_content_type(url)
+        
+        if content_type and content_type.startswith("image/"):
+            # Handle image - download to temp and print path (like browser-screenshot.js)
+            filepath = download_image(url)
+            print(filepath)
+        else:
+            # Handle webpage
+            content = fetch_webpage(url)
+            print(f"## Content from {url}")
+            print()
+            print(content)
+            
+    except HTTPError as e:
+        print(f"Error: HTTP {e.code} - {e.reason}", file=sys.stderr)
+        sys.exit(1)
+    except URLError as e:
+        print(f"Error: {e.reason}", file=sys.stderr)
+        sys.exit(1)
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/skills/web-search/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: web-search
+description: Web search using Jina Search API. Returns search results with titles, URLs, and descriptions. Use for finding documentation, facts, current information, or any web content. Lightweight, no browser required.
+---
+
+# Web Search
+
+Perform web searches using the Jina Search API. Returns formatted search results with titles, URLs, and descriptions.
+
+## Setup
+
+Optionally get a Jina API key for higher rate limits:
+1. Create an account at https://jina.ai/
+2. Get your API key from the dashboard
+3. Add to your shell profile (`~/.profile` or `~/.zprofile` for zsh):
+   ```bash
+   export JINA_API_KEY="your-api-key-here"
+   ```
+
+Without an API key, the service works with rate limits.
+
+## Usage
+
+```bash
+{baseDir}/search.py "your search query"
+```
+
+## Examples
+
+```bash
+# Basic search
+{baseDir}/search.py "python async await tutorial"
+
+# Search for recent news
+{baseDir}/search.py "latest AI developments 2024"
+
+# Find documentation
+{baseDir}/search.py "nodejs fs promises API"
+```
+
+## Output Format
+
+Returns markdown-formatted search results:
+
+```
+## Search Results
+
+[Title of first result](https://example.com/page1)
+Description or snippet from the search result...
+
+[Title of second result](https://example.com/page2)
+Description or snippet from the search result...
+```
+
+## When to Use
+
+- Searching for documentation or API references
+- Looking up facts or current information
+- Finding relevant web pages for research
+- Any task requiring web search without interactive browsing

package/skills/web-search/search.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+"""Web search using Jina Search API."""
+
+import os
+import sys
+import urllib.parse
+import urllib.request
+from urllib.error import HTTPError, URLError
+
+TIMEOUT = 30
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: search.py <query>")
+        print()
+        print("Searches the web using Jina Search API.")
+        print()
+        print("Environment:")
+        print("  JINA_API_KEY    Optional. Your Jina API key for higher rate limits.")
+        print()
+        print("Examples:")
+        print('  search.py "python async await"')
+        print('  search.py "rust ownership tutorial"')
+        sys.exit(1)
+    
+    query = " ".join(sys.argv[1:])
+    encoded_query = urllib.parse.quote(query)
+    url = f"https://s.jina.ai/?q={encoded_query}"
+    
+    # Build headers
+    headers = {
+        "User-Agent": "pi-skill/1.0",
+        "X-Respond-With": "no-content",
+        "Accept": "text/plain",
+    }
+    
+    api_key = os.environ.get("JINA_API_KEY")
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    
+    req = urllib.request.Request(url, headers=headers)
+    
+    try:
+        with urllib.request.urlopen(req, timeout=TIMEOUT) as response:
+            content = response.read().decode("utf-8", errors="replace").strip()
+            
+            if not content:
+                print("No search results found. Try a different query.")
+                sys.exit(0)
+            
+            print("## Search Results")
+            print()
+            print(content)
+            
+    except HTTPError as e:
+        print(f"Error: HTTP {e.code} - {e.reason}", file=sys.stderr)
+        sys.exit(1)
+    except URLError as e:
+        print(f"Error: {e.reason}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()