@dyyz1993/pi-coding-agent 0.69.18 → 0.69.25

package/examples/extensions/file-snapshot.ts

@@ -1,417 +0,0 @@
-import {
-	existsSync,
-	lstatSync,
-	mkdirSync,
-	readdirSync,
-	readFileSync,
-	realpathSync,
-	rmSync,
-	writeFileSync,
-} from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join, relative } from "node:path";
-import type { ExtensionAPI, ExtensionContext, SessionTreeEvent, TurnEndEvent } from "@dyyz1993/pi-coding-agent";
-
-function fnv1a(data: string): string {
-	let hash = 0x811c9dc5;
-	for (let i = 0; i < data.length; i++) {
-		hash ^= data.charCodeAt(i);
-		hash = Math.imul(hash, 0x01000193);
-	}
-	return hash.toString(16).padStart(8, "0");
-}
-
-const DEFAULT_IGNORE_PATTERNS = [
-	"node_modules",
-	".git",
-	".pi",
-	"dist",
-	"build",
-	".DS_Store",
-	"__pycache__",
-	".next",
-	".nuxt",
-	"target",
-	".gradle",
-	".idea",
-	".vscode",
-	"*.swp",
-	"*.swo",
-	"*.pyc",
-];
-
-function matchGlob(name: string, pattern: string): boolean {
-	if (pattern.startsWith("*.")) {
-		return name.endsWith(pattern.slice(1));
-	}
-	if (pattern.endsWith("/")) {
-		return name === pattern.slice(0, -1);
-	}
-	return name === pattern;
-}
-
-function shouldIgnore(relPath: string, extraPatterns: string[]): boolean {
-	const parts = relPath.split("/");
-	for (const part of parts) {
-		for (const pattern of DEFAULT_IGNORE_PATTERNS) {
-			if (matchGlob(part, pattern)) return true;
-		}
-		for (const pattern of extraPatterns) {
-			const trimmed = pattern.trim();
-			if (!trimmed || trimmed.startsWith("#")) continue;
-			if (trimmed.startsWith("!")) continue;
-			if (matchGlob(part, trimmed.replace(/^\/+/, ""))) return true;
-		}
-	}
-	return false;
-}
-
-function findCanonicalGitRoot(cwd: string): string | null {
-	let dir = realpathSync(cwd);
-	for (;;) {
-		const gitPath = join(dir, ".git");
-		if (!existsSync(gitPath)) {
-			const parent = dirname(dir);
-			if (parent === dir) return null;
-			dir = parent;
-			continue;
-		}
-		const stat = lstatSync(gitPath);
-		if (stat.isDirectory()) return dir;
-		if (stat.isFile()) {
-			const content = readFileSync(gitPath, "utf-8").trim();
-			const match = content.match(/^gitdir:\s*(.+)/);
-			if (!match) return null;
-			const gitdir = match[1]!.trim();
-			if (gitdir.includes("/worktrees/")) {
-				const commonPrefix = gitdir.replace(/\/worktrees\/[^/]+\/?$/, "");
-				let rootDir = commonPrefix;
-				if (rootDir.endsWith("/.git")) rootDir = rootDir.slice(0, -4);
-				if (!existsSync(join(rootDir, ".git"))) return null;
-				return realpathSync(rootDir);
-			}
-			const parent = dirname(gitdir);
-			if (!existsSync(parent)) return null;
-			return parent;
-		}
-		return null;
-	}
-}
-
-class ObjectStore {
-	private readonly objectsDir: string;
-
-	constructor(storeDir: string) {
-		this.objectsDir = join(storeDir, "objects");
-		mkdirSync(this.objectsDir, { recursive: true });
-	}
-
-	writeObject(content: string): string {
-		const hash = fnv1a(content);
-		const prefix = hash.slice(0, 2);
-		const suffix = hash.slice(2);
-		const dir = join(this.objectsDir, prefix);
-		const file = join(dir, suffix);
-		if (!existsSync(file)) {
-			mkdirSync(dir, { recursive: true });
-			writeFileSync(file, content, "utf-8");
-		}
-		return hash;
-	}
-
-	readObject(hash: string): string {
-		return readFileSync(join(this.objectsDir, hash.slice(0, 2), hash.slice(2)), "utf-8");
-	}
-
-	hasObject(hash: string): boolean {
-		return existsSync(join(this.objectsDir, hash.slice(0, 2), hash.slice(2)));
-	}
-
-	scanWorkingDir(cwd: string): Map<string, string> {
-		const gitignorePatterns: string[] = [];
-		const gitignorePath = join(cwd, ".gitignore");
-		if (existsSync(gitignorePath)) {
-			try {
-				gitignorePatterns.push(...readFileSync(gitignorePath, "utf-8").split(/\r?\n/));
-			} catch {}
-		}
-		const result = new Map<string, string>();
-		this.scanDir(cwd, cwd, gitignorePatterns, result);
-		return result;
-	}
-
-	private scanDir(dir: string, root: string, extraPatterns: string[], result: Map<string, string>): void {
-		let entries: ReturnType<typeof readdirSync>;
-		try {
-			entries = readdirSync(dir, { withFileTypes: true });
-		} catch {
-			return;
-		}
-		for (const entry of entries) {
-			const fullPath = join(dir, entry.name);
-			const relPath = relative(root, fullPath);
-			if (entry.isDirectory()) {
-				if (shouldIgnore(`${relPath}/`, extraPatterns)) continue;
-				this.scanDir(fullPath, root, extraPatterns, result);
-			} else if (entry.isFile()) {
-				if (shouldIgnore(relPath, extraPatterns)) continue;
-				try {
-					const stat = lstatSync(fullPath);
-					if (stat.size > 1024 * 1024) continue;
-					const content = readFileSync(fullPath, "utf-8");
-					result.set(relPath, content);
-				} catch {}
-			}
-		}
-	}
-
-	writeTree(files: Map<string, string>): string {
-		const entries: Array<{ path: string; hash: string }> = [];
-		for (const [path, content] of files) {
-			const hash = this.writeObject(content);
-			entries.push({ path, hash });
-		}
-		entries.sort((a, b) => a.path.localeCompare(b.path));
-		const treeData = entries.map((e) => `${e.path}\0${e.hash}`).join("\n");
-		return this.writeObject(treeData);
-	}
-
-	readTree(treeHash: string): Map<string, string> {
-		const treeData = this.readObject(treeHash);
-		const files = new Map<string, string>();
-		for (const line of treeData.split("\n")) {
-			if (!line) continue;
-			const sep = line.indexOf("\0");
-			if (sep === -1) continue;
-			const path = line.slice(0, sep);
-			const hash = line.slice(sep + 1);
-			if (this.hasObject(hash)) {
-				files.set(path, this.readObject(hash));
-			}
-		}
-		return files;
-	}
-
-	parseTreeEntries(treeHash: string): Map<string, string> {
-		const treeData = this.readObject(treeHash);
-		const entries = new Map<string, string>();
-		for (const line of treeData.split("\n")) {
-			if (!line) continue;
-			const sep = line.indexOf("\0");
-			if (sep === -1) continue;
-			entries.set(line.slice(0, sep), line.slice(sep + 1));
-		}
-		return entries;
-	}
-
-	computeTreeDiff(
-		oldTreeHash: string | null,
-		newTreeHash: string,
-	): { added: string[]; modified: string[]; deleted: string[] } {
-		const oldEntries = oldTreeHash ? this.parseTreeEntries(oldTreeHash) : new Map<string, string>();
-		const newEntries = this.parseTreeEntries(newTreeHash);
-
-		const added: string[] = [];
-		const modified: string[] = [];
-		const deleted: string[] = [];
-
-		for (const [path, hash] of newEntries) {
-			const old = oldEntries.get(path);
-			if (!old) added.push(path);
-			else if (old !== hash) modified.push(path);
-		}
-		for (const path of oldEntries.keys()) {
-			if (!newEntries.has(path)) deleted.push(path);
-		}
-
-		return { added: added.sort(), modified: modified.sort(), deleted: deleted.sort() };
-	}
-}
-
-interface StepSnapshot {
-	baselineTreeHash: string | null;
-	snapshotTreeHash: string;
-	diff: { added: string[]; modified: string[]; deleted: string[] } | null;
-	turnIndex: number;
-}
-
-interface UnrevertPoint {
-	preRollbackTreeHash: string;
-	rolledBackToLeaf: string;
-	restoredFiles: string[];
-}
-
-function getStoreRoot(): string {
-	return join(homedir(), ".pi", "agent", "file-store");
-}
-
-export default function fileSnapshot(pi: ExtensionAPI) {
-	let store: ObjectStore | null = null;
-	let sessionStartTreeHash: string | null = null;
-	let lastCommittedTreeHash: string | null = null;
-	let turnIndex = 0;
-	let _sessionBaselinePaths: Set<string> = new Set();
-
-	function getStore(ctx: ExtensionContext): ObjectStore {
-		if (!store) {
-			const projectRoot = findCanonicalGitRoot(ctx.cwd) ?? ctx.cwd;
-			const projectHash = fnv1a(projectRoot);
-			store = new ObjectStore(join(getStoreRoot(), projectHash));
-		}
-		return store;
-	}
-
-	pi.on("session_start", async (_event: unknown, ctx: ExtensionContext) => {
-		store = null;
-		sessionStartTreeHash = null;
-		lastCommittedTreeHash = null;
-		turnIndex = 0;
-		const s = getStore(ctx);
-		const files = s.scanWorkingDir(ctx.cwd);
-		_sessionBaselinePaths = new Set(files.keys());
-		if (files.size > 0) {
-			sessionStartTreeHash = s.writeTree(files);
-		}
-	});
-
-	pi.on("turn_end", async (_event: TurnEndEvent, ctx: ExtensionContext) => {
-		const s = getStore(ctx);
-		const files = s.scanWorkingDir(ctx.cwd);
-		const snapshotTreeHash = s.writeTree(files);
-
-		const compareTo = lastCommittedTreeHash ?? sessionStartTreeHash;
-		const isFirstSnapshot = !lastCommittedTreeHash && files.size > 0;
-		const diff = compareTo ? s.computeTreeDiff(compareTo, snapshotTreeHash || "") : null;
-		const hasChanges = diff && (diff.added.length > 0 || diff.modified.length > 0 || diff.deleted.length > 0);
-
-		if (hasChanges || isFirstSnapshot) {
-			pi.appendEntry(
-				"step-snapshot",
-				{
-					baselineTreeHash: compareTo,
-					snapshotTreeHash,
-					diff: hasChanges ? diff : null,
-					turnIndex,
-				} satisfies StepSnapshot,
-				{ display: false },
-			);
-			lastCommittedTreeHash = snapshotTreeHash || null;
-		}
-
-		turnIndex++;
-	});
-
-	pi.on("session_tree", async (event: SessionTreeEvent, ctx: ExtensionContext) => {
-		if (event.skipFiles) return;
-
-		const targetId = event.newLeafId;
-		const s = getStore(ctx);
-		const entries = ctx.sessionManager.getEntries();
-
-		let targetTreeHash: string | null;
-		let currentTreeHash2: string | null;
-
-		if (!targetId) {
-			targetTreeHash = sessionStartTreeHash ?? null;
-			const currentSnapshot = findLatestSnapshotOnPath(entries, event.oldLeafId);
-			currentTreeHash2 = currentSnapshot?.snapshotTreeHash ?? null;
-		} else {
-			const targetEntry = entries.find((e) => e.id === targetId);
-			const isRootTarget = targetEntry && !targetEntry.parentId;
-
-			const targetSnapshot = isRootTarget ? null : findLatestSnapshotOnPath(entries, targetId);
-			const currentSnapshot = findLatestSnapshotOnPath(entries, event.oldLeafId);
-
-			targetTreeHash = targetSnapshot?.snapshotTreeHash ?? sessionStartTreeHash ?? null;
-			currentTreeHash2 = currentSnapshot?.snapshotTreeHash ?? null;
-		}
-
-		if (targetTreeHash === currentTreeHash2) return;
-
-		const targetFiles = targetTreeHash ? s.readTree(targetTreeHash) : new Map<string, string>();
-		const currentFiles = currentTreeHash2 ? s.readTree(currentTreeHash2) : new Map<string, string>();
-
-		const toRestore: string[] = [];
-		for (const [path, content] of targetFiles) {
-			const current = currentFiles.get(path);
-			if (current !== content) {
-				toRestore.push(path);
-			}
-		}
-
-		const toDelete: string[] = [];
-		for (const path of currentFiles.keys()) {
-			if (!targetFiles.has(path)) {
-				toDelete.push(path);
-			}
-		}
-
-		if (toRestore.length === 0 && toDelete.length === 0) return;
-
-		if (event.preview) {
-			return { restored: toRestore.sort(), deleted: toDelete.sort() };
-		}
-
-		const preRollbackFiles = s.scanWorkingDir(ctx.cwd);
-		const preRollbackTreeHash = preRollbackFiles.size > 0 ? s.writeTree(preRollbackFiles) : "";
-
-		pi.appendEntry("unrevert-point", {
-			preRollbackTreeHash,
-			rolledBackToLeaf: targetId ?? "",
-			restoredFiles: toRestore,
-		} satisfies UnrevertPoint);
-
-		restoreFiles(ctx.cwd, new Map(toRestore.map((p) => [p, targetFiles.get(p)!])));
-		deleteFiles(ctx.cwd, toDelete);
-	});
-}
-
-function restoreFiles(cwd: string, toRestore: Map<string, string>): void {
-	for (const [path, content] of toRestore) {
-		const absPath = join(cwd, path);
-		mkdirSync(join(absPath, ".."), { recursive: true });
-		writeFileSync(absPath, content, "utf-8");
-	}
-}
-
-function deleteFiles(cwd: string, paths: string[]): void {
-	for (const path of paths) {
-		const absPath = join(cwd, path);
-		if (existsSync(absPath)) {
-			rmSync(absPath, { force: true });
-		}
-	}
-}
-
-function findLatestSnapshotOnPath(
-	entries: Array<{ id: string; parentId: string | null; type: string; customType?: string; data?: unknown }>,
-	leafId: string | null,
-): StepSnapshot | null {
-	if (!leafId) return null;
-
-	const byId = new Map(entries.map((e) => [e.id, e]));
-	const snapshots: StepSnapshot[] = [];
-
-	for (const entry of entries) {
-		if (entry.type !== "custom" || entry.customType !== "step-snapshot") continue;
-		if (!isOnPathTo(byId, leafId, entry.id)) continue;
-		snapshots.push(entry.data as StepSnapshot);
-	}
-
-	return snapshots.length > 0 ? snapshots[snapshots.length - 1] : null;
-}
-
-function isOnPathTo(
-	byId: Map<string, { id: string; parentId: string | null }>,
-	startId: string,
-	targetId: string,
-): boolean {
-	let current: string | null = startId;
-	while (current !== null) {
-		if (current === targetId) return true;
-		const entry = byId.get(current);
-		if (!entry) break;
-		current = entry.parentId;
-	}
-	return false;
-}

package/examples/extensions/subagent/README.md

@@ -1,172 +0,0 @@
-# Subagent Example
-
-Delegate tasks to specialized subagents with isolated context windows.
-
-## Features
-
-- **Isolated context**: Each subagent runs in a separate `pi` process
-- **Streaming output**: See tool calls and progress as they happen
-- **Parallel streaming**: All parallel tasks stream updates simultaneously
-- **Markdown rendering**: Final output rendered with proper formatting (expanded view)
-- **Usage tracking**: Shows turns, tokens, cost, and context usage per agent
-- **Abort support**: Ctrl+C propagates to kill subagent processes
-
-## Structure
-
-```
-subagent/
-├── README.md            # This file
-├── index.ts             # The extension (entry point)
-├── agents.ts            # Agent discovery logic
-├── agents/              # Sample agent definitions
-│   ├── scout.md         # Fast recon, returns compressed context
-│   ├── planner.md       # Creates implementation plans
-│   ├── reviewer.md      # Code review
-│   └── worker.md        # General-purpose (full capabilities)
-└── prompts/             # Workflow presets (prompt templates)
-    ├── implement.md     # scout -> planner -> worker
-    ├── scout-and-plan.md    # scout -> planner (no implementation)
-    └── implement-and-review.md  # worker -> reviewer -> worker
-```
-
-## Installation
-
-From the repository root, symlink the files:
-
-```bash
-# Symlink the extension (must be in a subdirectory with index.ts)
-mkdir -p ~/.pi/agent/extensions/subagent
-ln -sf "$(pwd)/packages/coding-agent/examples/extensions/subagent/index.ts" ~/.pi/agent/extensions/subagent/index.ts
-ln -sf "$(pwd)/packages/coding-agent/examples/extensions/subagent/agents.ts" ~/.pi/agent/extensions/subagent/agents.ts
-
-# Symlink agents
-mkdir -p ~/.pi/agent/agents
-for f in packages/coding-agent/examples/extensions/subagent/agents/*.md; do
-  ln -sf "$(pwd)/$f" ~/.pi/agent/agents/$(basename "$f")
-done
-
-# Symlink workflow prompts
-mkdir -p ~/.pi/agent/prompts
-for f in packages/coding-agent/examples/extensions/subagent/prompts/*.md; do
-  ln -sf "$(pwd)/$f" ~/.pi/agent/prompts/$(basename "$f")
-done
-```
-
-## Security Model
-
-This tool executes a separate `pi` subprocess with a delegated system prompt and tool/model configuration.
-
-**Project-local agents** (`.pi/agents/*.md`) are repo-controlled prompts that can instruct the model to read files, run bash commands, etc.
-
-**Default behavior:** Only loads **user-level agents** from `~/.pi/agent/agents`.
-
-To enable project-local agents, pass `agentScope: "both"` (or `"project"`). Only do this for repositories you trust.
-
-When running interactively, the tool prompts for confirmation before running project-local agents. Set `confirmProjectAgents: false` to disable.
-
-## Usage
-
-### Single agent
-```
-Use scout to find all authentication code
-```
-
-### Parallel execution
-```
-Run 2 scouts in parallel: one to find models, one to find providers
-```
-
-### Chained workflow
-```
-Use a chain: first have scout find the read tool, then have planner suggest improvements
-```
-
-### Workflow prompts
-```
-/implement add Redis caching to the session store
-/scout-and-plan refactor auth to support OAuth
-/implement-and-review add input validation to API endpoints
-```
-
-## Tool Modes
-
-| Mode | Parameter | Description |
-|------|-----------|-------------|
-| Single | `{ agent, task }` | One agent, one task |
-| Parallel | `{ tasks: [...] }` | Multiple agents run concurrently (max 8, 4 concurrent) |
-| Chain | `{ chain: [...] }` | Sequential with `{previous}` placeholder |
-
-## Output Display
-
-**Collapsed view** (default):
-- Status icon (✓/✗/⏳) and agent name
-- Last 5-10 items (tool calls and text)
-- Usage stats: `3 turns ↑input ↓output RcacheRead WcacheWrite $cost ctx:contextTokens model`
-
-**Expanded view** (Ctrl+O):
-- Full task text
-- All tool calls with formatted arguments
-- Final output rendered as Markdown
-- Per-task usage (for chain/parallel)
-
-**Parallel mode streaming**:
-- Shows all tasks with live status (⏳ running, ✓ done, ✗ failed)
-- Updates as each task makes progress
-- Shows "2/3 done, 1 running" status
-
-**Tool call formatting** (mimics built-in tools):
-- `$ command` for bash
-- `read ~/path:1-10` for read
-- `grep /pattern/ in ~/path` for grep
-- etc.
-
-## Agent Definitions
-
-Agents are markdown files with YAML frontmatter:
-
-```markdown
----
-name: my-agent
-description: What this agent does
-tools: read, grep, find, ls
-model: claude-haiku-4-5
----
-
-System prompt for the agent goes here.
-```
-
-**Locations:**
-- `~/.pi/agent/agents/*.md` - User-level (always loaded)
-- `.pi/agents/*.md` - Project-level (only with `agentScope: "project"` or `"both"`)
-
-Project agents override user agents with the same name when `agentScope: "both"`.
-
-## Sample Agents
-
-| Agent | Purpose | Model | Tools |
-|-------|---------|-------|-------|
-| `scout` | Fast codebase recon | Haiku | read, grep, find, ls, bash |
-| `planner` | Implementation plans | Sonnet | read, grep, find, ls |
-| `reviewer` | Code review | Sonnet | read, grep, find, ls, bash |
-| `worker` | General-purpose | Sonnet | (all default) |
-
-## Workflow Prompts
-
-| Prompt | Flow |
-|--------|------|
-| `/implement <query>` | scout → planner → worker |
-| `/scout-and-plan <query>` | scout → planner |
-| `/implement-and-review <query>` | worker → reviewer → worker |
-
-## Error Handling
-
-- **Exit code != 0**: Tool returns error with stderr/output
-- **stopReason "error"**: LLM error propagated with error message
-- **stopReason "aborted"**: User abort (Ctrl+C) kills subprocess, throws error
-- **Chain mode**: Stops at first failing step, reports which step failed
-
-## Limitations
-
-- Output truncated to last 10 items in collapsed view (expand to see all)
-- Agents discovered fresh on each invocation (allows editing mid-session)
-- Parallel mode limited to 8 tasks, 4 concurrent

package/examples/extensions/subagent/agents/planner.md

@@ -1,37 +0,0 @@
----
-name: planner
-description: Creates implementation plans from context and requirements
-tools: read, grep, find, ls
-model: claude-sonnet-4-5
----
-
-You are a planning specialist. You receive context (from a scout) and requirements, then produce a clear implementation plan.
-
-You must NOT make any changes. Only read, analyze, and plan.
-
-Input format you'll receive:
-- Context/findings from a scout agent
-- Original query or requirements
-
-Output format:
-
-## Goal
-One sentence summary of what needs to be done.
-
-## Plan
-Numbered steps, each small and actionable:
-1. Step one - specific file/function to modify
-2. Step two - what to add/change
-3. ...
-
-## Files to Modify
-- `path/to/file.ts` - what changes
-- `path/to/other.ts` - what changes
-
-## New Files (if any)
-- `path/to/new.ts` - purpose
-
-## Risks
-Anything to watch out for.
-
-Keep the plan concrete. The worker agent will execute it verbatim.

package/examples/extensions/subagent/agents/reviewer.md

@@ -1,35 +0,0 @@
----
-name: reviewer
-description: Code review specialist for quality and security analysis
-tools: read, grep, find, ls, bash
-model: claude-sonnet-4-5
----
-
-You are a senior code reviewer. Analyze code for quality, security, and maintainability.
-
-Bash is for read-only commands only: `git diff`, `git log`, `git show`. Do NOT modify files or run builds.
-Assume tool permissions are not perfectly enforceable; keep all bash usage strictly read-only.
-
-Strategy:
-1. Run `git diff` to see recent changes (if applicable)
-2. Read the modified files
-3. Check for bugs, security issues, code smells
-
-Output format:
-
-## Files Reviewed
-- `path/to/file.ts` (lines X-Y)
-
-## Critical (must fix)
-- `file.ts:42` - Issue description
-
-## Warnings (should fix)
-- `file.ts:100` - Issue description
-
-## Suggestions (consider)
-- `file.ts:150` - Improvement idea
-
-## Summary
-Overall assessment in 2-3 sentences.
-
-Be specific with file paths and line numbers.

package/examples/extensions/subagent/agents/scout.md

@@ -1,50 +0,0 @@
----
-name: scout
-description: Fast codebase recon that returns compressed context for handoff to other agents
-tools: read, grep, find, ls, bash
-model: claude-haiku-4-5
----
-
-You are a scout. Quickly investigate a codebase and return structured findings that another agent can use without re-reading everything.
-
-Your output will be passed to an agent who has NOT seen the files you explored.
-
-Thoroughness (infer from task, default medium):
-- Quick: Targeted lookups, key files only
-- Medium: Follow imports, read critical sections
-- Thorough: Trace all dependencies, check tests/types
-
-Strategy:
-1. grep/find to locate relevant code
-2. Read key sections (not entire files)
-3. Identify types, interfaces, key functions
-4. Note dependencies between files
-
-Output format:
-
-## Files Retrieved
-List with exact line ranges:
-1. `path/to/file.ts` (lines 10-50) - Description of what's here
-2. `path/to/other.ts` (lines 100-150) - Description
-3. ...
-
-## Key Code
-Critical types, interfaces, or functions:
-
-```typescript
-interface Example {
-  // actual code from the files
-}
-```
-
-```typescript
-function keyFunction() {
-  // actual implementation
-}
-```
-
-## Architecture
-Brief explanation of how the pieces connect.
-
-## Start Here
-Which file to look at first and why.