@oh-my-pi/pi-coding-agent 3.15.1 → 3.20.0

package/src/discovery/helpers.ts

@@ -2,7 +2,7 @@
  * Shared helpers for discovery providers.
  */
 
-import { join, resolve } from "node:path";
+import { join, resolve } from "path";
 import { parse as parseYAML } from "yaml";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
 
@@ -247,3 +247,102 @@ export function parseJSON<T>(content: string): T | null {
 export function calculateDepth(cwd: string, targetDir: string, separator: string): number {
 	return cwd.split(separator).length - targetDir.split(separator).length;
 }
+
+interface ExtensionModuleManifest {
+	extensions?: string[];
+}
+
+function readExtensionModuleManifest(ctx: LoadContext, packageJsonPath: string): ExtensionModuleManifest | null {
+	const content = ctx.fs.readFile(packageJsonPath);
+	if (!content) return null;
+
+	const pkg = parseJSON<{ omp?: ExtensionModuleManifest; pi?: ExtensionModuleManifest }>(content);
+	const manifest = pkg?.omp ?? pkg?.pi;
+	if (manifest && typeof manifest === "object") {
+		return manifest;
+	}
+	return null;
+}
+
+function isExtensionModuleFile(name: string): boolean {
+	return name.endsWith(".ts") || name.endsWith(".js");
+}
+
+/**
+ * Discover extension module entry points in a directory.
+ *
+ * Discovery rules:
+ * 1. Direct files: `extensions/*.ts` or `*.js` → load
+ * 2. Subdirectory with index: `extensions/<ext>/index.ts` or `index.js` → load
+ * 3. Subdirectory with package.json: `extensions/<ext>/package.json` with "omp"/"pi" field → load declared paths
+ *
+ * No recursion beyond one level. Complex packages must use package.json manifest.
+ */
+export function discoverExtensionModulePaths(ctx: LoadContext, dir: string): string[] {
+	if (!ctx.fs.isDir(dir)) {
+		return [];
+	}
+
+	const discovered: string[] = [];
+
+	for (const name of ctx.fs.readDir(dir)) {
+		if (name.startsWith(".")) continue;
+
+		const entryPath = join(dir, name);
+
+		// 1. Direct files: *.ts or *.js
+		if (ctx.fs.isFile(entryPath) && isExtensionModuleFile(name)) {
+			discovered.push(entryPath);
+			continue;
+		}
+
+		// 2 & 3. Subdirectories
+		if (ctx.fs.isDir(entryPath)) {
+			// Check for package.json with "omp"/"pi" field first
+			const packageJsonPath = join(entryPath, "package.json");
+			if (ctx.fs.isFile(packageJsonPath)) {
+				const manifest = readExtensionModuleManifest(ctx, packageJsonPath);
+				if (manifest?.extensions && Array.isArray(manifest.extensions)) {
+					for (const extPath of manifest.extensions) {
+						const resolvedExtPath = resolve(entryPath, extPath);
+						if (ctx.fs.isFile(resolvedExtPath)) {
+							discovered.push(resolvedExtPath);
+						}
+					}
+					continue;
+				}
+			}
+
+			// Check for index.ts or index.js
+			const indexTs = join(entryPath, "index.ts");
+			const indexJs = join(entryPath, "index.js");
+			if (ctx.fs.isFile(indexTs)) {
+				discovered.push(indexTs);
+			} else if (ctx.fs.isFile(indexJs)) {
+				discovered.push(indexJs);
+			}
+		}
+	}
+
+	return discovered;
+}
+
+/**
+ * Derive a stable extension name from a path.
+ */
+export function getExtensionNameFromPath(extensionPath: string): string {
+	const base = extensionPath.replace(/\\/g, "/").split("/").pop() ?? extensionPath;
+
+	if (base === "index.ts" || base === "index.js") {
+		const parts = extensionPath.replace(/\\/g, "/").split("/");
+		const parent = parts[parts.length - 2];
+		return parent ?? base;
+	}
+
+	const dot = base.lastIndexOf(".");
+	if (dot > 0) {
+		return base.slice(0, dot);
+	}
+
+	return base;
+}

package/src/discovery/index.ts

@@ -8,6 +8,7 @@
 // Import capability definitions (ensures capabilities are defined before providers register)
 import "../capability/context-file";
 import "../capability/extension";
+import "../capability/extension-module";
 import "../capability/hook";
 import "../capability/instruction";
 import "../capability/mcp";
@@ -34,6 +35,7 @@ import "./mcp-json";
 
 export type { ContextFile } from "../capability/context-file";
 export type { Extension, ExtensionManifest } from "../capability/extension";
+export type { ExtensionModule } from "../capability/extension-module";
 export type { Hook } from "../capability/hook";
 // Re-export the main API from capability registry
 export {

package/src/index.ts

@@ -60,6 +60,8 @@ export type {
 	RenderResultOptions,
 } from "./core/custom-tools/index";
 export { discoverAndLoadCustomTools, loadCustomTools } from "./core/custom-tools/index";
+// Extension types
+export type { ExtensionAPI, ExtensionContext, ExtensionFactory } from "./core/extensions/types";
 export type * from "./core/hooks/index";
 // Hook system types and type guards
 export {
@@ -75,6 +77,8 @@ export {
 export { type Logger, logger } from "./core/logger";
 export { convertToLlm } from "./core/messages";
 export { ModelRegistry } from "./core/model-registry";
+// Prompt templates
+export type { PromptTemplate } from "./core/prompt-templates";
 // SDK for programmatic usage
 export {
 	type BuildSystemPromptOptions,
@@ -96,16 +100,12 @@ export {
 	// Discovery
 	discoverAuthStorage,
 	discoverContextFiles,
-	discoverCustomTools,
-	discoverHooks,
+	discoverCustomTSCommands,
+	discoverExtensions,
+	discoverMCPServers,
 	discoverModels,
+	discoverPromptTemplates,
 	discoverSkills,
-	discoverSlashCommands,
-	type FileSlashCommand,
-	// Hook types
-	type HookAPI,
-	type HookContext,
-	type HookFactory,
 	loadSettings,
 	// Pre-built tools (use process.cwd())
 	readOnlyTools,
@@ -134,6 +134,7 @@ export {
 } from "./core/session-manager";
 export {
 	type CompactionSettings,
+	type ImageSettings,
 	type LspSettings,
 	type RetrySettings,
 	type Settings,
@@ -151,6 +152,8 @@ export {
 	type SkillFrontmatter,
 	type SkillWarning,
 } from "./core/skills";
+// Slash commands
+export { type FileSlashCommand, loadSlashCommands as discoverSlashCommands } from "./core/slash-commands";
 // Tools
 export {
 	type BashToolDetails,
@@ -160,7 +163,9 @@ export {
 	editTool,
 	type FindToolDetails,
 	findTool,
+	type GitToolDetails,
 	type GrepToolDetails,
+	gitTool,
 	grepTool,
 	type LsToolDetails,
 	lsTool,
@@ -177,7 +182,7 @@ export { main } from "./main";
 // UI components for hooks and custom tools
 export { BorderedLoader } from "./modes/interactive/components/bordered-loader";
 // Theme utilities for custom tools
-export { getMarkdownTheme } from "./modes/interactive/theme/theme";
+export { getMarkdownTheme, getSettingsListTheme, type Theme } from "./modes/interactive/theme/theme";
 
 // TypeBox helper for string enums (convenience for custom tools)
 import { type TSchema, Type } from "@sinclair/typebox";

package/src/lib/worktree/collapse.ts

@@ -0,0 +1,179 @@
+import { WorktreeError, WorktreeErrorCode } from "./errors";
+import { git, gitWithStdin } from "./git";
+import { find, remove, type Worktree } from "./operations";
+
+export type CollapseStrategy = "simple" | "merge-base" | "rebase";
+
+export interface CollapseOptions {
+	strategy?: CollapseStrategy;
+	keepSource?: boolean;
+}
+
+export interface CollapseResult {
+	filesChanged: number;
+	insertions: number;
+	deletions: number;
+}
+
+function diffStats(diff: string): CollapseResult {
+	let filesChanged = 0;
+	let insertions = 0;
+	let deletions = 0;
+
+	for (const line of diff.split("\n")) {
+		if (line.startsWith("diff --git ")) {
+			filesChanged += 1;
+			continue;
+		}
+		if (line.startsWith("+++") || line.startsWith("---")) continue;
+		if (line.startsWith("+")) {
+			insertions += 1;
+			continue;
+		}
+		if (line.startsWith("-")) {
+			deletions += 1;
+		}
+	}
+
+	return { filesChanged, insertions, deletions };
+}
+
+async function requireGitSuccess(result: { code: number; stderr: string }, message: string): Promise<void> {
+	if (result.code !== 0) {
+		throw new WorktreeError(
+			message + (result.stderr ? `\n${result.stderr.trim()}` : ""),
+			WorktreeErrorCode.COLLAPSE_FAILED,
+		);
+	}
+}
+
+async function ensureHasChanges(result: { stdout: string }): Promise<string> {
+	const diff = result.stdout;
+	if (!diff.trim()) {
+		throw new WorktreeError("No changes to collapse", WorktreeErrorCode.NO_CHANGES);
+	}
+	return diff;
+}
+
+async function collapseSimple(src: Worktree): Promise<string> {
+	await requireGitSuccess(await git(["add", "-A"], src.path), "Failed to stage changes");
+	return ensureHasChanges(await git(["diff", "HEAD"], src.path));
+}
+
+async function collapseMergeBase(src: Worktree, dst: Worktree): Promise<string> {
+	await requireGitSuccess(await git(["add", "-A"], src.path), "Failed to stage changes");
+
+	const baseResult = await git(["merge-base", "HEAD", dst.branch ?? "HEAD"], src.path);
+	if (baseResult.code !== 0) {
+		throw new WorktreeError("Could not find merge base", WorktreeErrorCode.COLLAPSE_FAILED);
+	}
+
+	const base = baseResult.stdout.trim();
+	if (!base) {
+		throw new WorktreeError("Could not find merge base", WorktreeErrorCode.COLLAPSE_FAILED);
+	}
+
+	return ensureHasChanges(await git(["diff", base], src.path));
+}
+
+async function collapseRebase(src: Worktree, dst: Worktree): Promise<string> {
+	await requireGitSuccess(await git(["add", "-A"], src.path), "Failed to stage changes");
+
+	const stagedResult = await git(["diff", "--cached", "--name-only"], src.path);
+	if (!stagedResult.stdout.trim()) {
+		throw new WorktreeError("No changes to collapse", WorktreeErrorCode.NO_CHANGES);
+	}
+
+	const headResult = await git(["rev-parse", "HEAD"], src.path);
+	if (headResult.code !== 0) {
+		throw new WorktreeError("Failed to resolve HEAD", WorktreeErrorCode.COLLAPSE_FAILED);
+	}
+	const originalHead = headResult.stdout.trim();
+	const tempBranch = `wt-collapse-${Date.now()}`;
+
+	await requireGitSuccess(await git(["checkout", "-b", tempBranch], src.path), "Failed to create temp branch");
+
+	const commitResult = await git(["commit", "--allow-empty-message", "-m", ""], src.path);
+	if (commitResult.code !== 0) {
+		await git(["checkout", originalHead], src.path);
+		await git(["branch", "-D", tempBranch], src.path);
+		throw new WorktreeError("Failed to commit changes", WorktreeErrorCode.COLLAPSE_FAILED);
+	}
+
+	const rebaseResult = await git(["rebase", dst.branch ?? "HEAD"], src.path);
+	if (rebaseResult.code !== 0) {
+		await git(["rebase", "--abort"], src.path);
+		await git(["checkout", originalHead], src.path);
+		await git(["branch", "-D", tempBranch], src.path);
+		throw new WorktreeError(
+			`Rebase conflicts:${rebaseResult.stderr ? `\n${rebaseResult.stderr.trim()}` : ""}`,
+			WorktreeErrorCode.REBASE_CONFLICTS,
+		);
+	}
+
+	const diffResult = await git(["diff", `${dst.branch ?? "HEAD"}..HEAD`], src.path);
+
+	await git(["checkout", originalHead], src.path);
+	await git(["branch", "-D", tempBranch], src.path);
+
+	return ensureHasChanges(diffResult);
+}
+
+async function applyDiff(diff: string, targetPath: string): Promise<void> {
+	let result = await gitWithStdin(["apply"], diff, targetPath);
+	if (result.code === 0) return;
+
+	result = await gitWithStdin(["apply", "--3way"], diff, targetPath);
+	if (result.code === 0) return;
+
+	throw new WorktreeError(
+		`Failed to apply diff:${result.stderr ? `\n${result.stderr.trim()}` : ""}`,
+		WorktreeErrorCode.APPLY_FAILED,
+	);
+}
+
+/**
+ * Collapse changes from source worktree into destination.
+ */
+export async function collapse(
+	source: string,
+	destination: string,
+	options?: CollapseOptions,
+): Promise<CollapseResult> {
+	const src = await find(source);
+	const dst = await find(destination);
+
+	if (src.path === dst.path) {
+		throw new WorktreeError("Source and destination are the same", WorktreeErrorCode.COLLAPSE_FAILED);
+	}
+
+	if (!options?.keepSource && src.isMain) {
+		throw new WorktreeError("Cannot remove main worktree", WorktreeErrorCode.CANNOT_MODIFY_MAIN);
+	}
+
+	const strategy = options?.strategy ?? "rebase";
+	let diff: string;
+
+	switch (strategy) {
+		case "simple":
+			diff = await collapseSimple(src);
+			break;
+		case "merge-base":
+			diff = await collapseMergeBase(src, dst);
+			break;
+		case "rebase":
+			diff = await collapseRebase(src, dst);
+			break;
+		default:
+			throw new WorktreeError(`Unknown strategy: ${strategy}`, WorktreeErrorCode.COLLAPSE_FAILED);
+	}
+
+	const stats = diffStats(diff);
+	await applyDiff(diff, dst.path);
+
+	if (!options?.keepSource) {
+		await remove(src.path, { force: true });
+	}
+
+	return stats;
+}

package/src/lib/worktree/constants.ts

@@ -0,0 +1,14 @@
+import { accessSync, constants } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+function getWorktreeBase(): string {
+   try {
+      accessSync("/work", constants.W_OK);
+      return "/work/.tree";
+   } catch {
+      return path.join(os.tmpdir(), ".tree");
+   }
+}
+
+export const WORKTREE_BASE = getWorktreeBase();

package/src/lib/worktree/errors.ts

@@ -0,0 +1,23 @@
+export enum WorktreeErrorCode {
+	NOT_GIT_REPO = "NOT_GIT_REPO",
+	WORKTREE_NOT_FOUND = "WORKTREE_NOT_FOUND",
+	WORKTREE_EXISTS = "WORKTREE_EXISTS",
+	CANNOT_MODIFY_MAIN = "CANNOT_MODIFY_MAIN",
+	NO_CHANGES = "NO_CHANGES",
+	COLLAPSE_FAILED = "COLLAPSE_FAILED",
+	REBASE_CONFLICTS = "REBASE_CONFLICTS",
+	APPLY_FAILED = "APPLY_FAILED",
+	OVERLAPPING_SCOPES = "OVERLAPPING_SCOPES",
+}
+
+export class WorktreeError extends Error {
+	readonly code: WorktreeErrorCode;
+	readonly cause?: Error;
+
+	constructor(message: string, code: WorktreeErrorCode, cause?: Error) {
+		super(message);
+		this.name = "WorktreeError";
+		this.code = code;
+		this.cause = cause;
+	}
+}

package/src/lib/worktree/git.ts

@@ -0,0 +1,110 @@
+import * as path from "node:path";
+import type { Subprocess } from "bun";
+import { execCommand } from "../../core/exec";
+import { WorktreeError, WorktreeErrorCode } from "./errors";
+
+export interface GitResult {
+	code: number;
+	stdout: string;
+	stderr: string;
+}
+
+type WritableLike = {
+	write: (chunk: string | Uint8Array) => unknown;
+	flush?: () => unknown;
+	end?: () => unknown;
+};
+
+const textEncoder = new TextEncoder();
+
+async function readStream(stream: ReadableStream<Uint8Array> | undefined): Promise<string> {
+	if (!stream) return "";
+	const reader = stream.getReader();
+	const chunks: Uint8Array[] = [];
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			chunks.push(value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	return Buffer.concat(chunks).toString();
+}
+
+async function writeStdin(handle: unknown, stdin: string): Promise<void> {
+	if (!handle || typeof handle === "number") return;
+	if (typeof (handle as WritableStream<Uint8Array>).getWriter === "function") {
+		const writer = (handle as WritableStream<Uint8Array>).getWriter();
+		try {
+			await writer.write(textEncoder.encode(stdin));
+		} finally {
+			await writer.close();
+		}
+		return;
+	}
+
+	const sink = handle as WritableLike;
+	sink.write(stdin);
+	if (sink.flush) sink.flush();
+	if (sink.end) sink.end();
+}
+
+/**
+ * Execute a git command.
+ * @param args - Command arguments (excluding 'git')
+ * @param cwd - Working directory (optional)
+ * @returns Promise<GitResult>
+ */
+export async function git(args: string[], cwd?: string): Promise<GitResult> {
+	const result = await execCommand("git", args, cwd ?? process.cwd());
+	return { code: result.code, stdout: result.stdout, stderr: result.stderr };
+}
+
+/**
+ * Execute git command with stdin input.
+ * Used for piping diffs to `git apply`.
+ */
+export async function gitWithStdin(args: string[], stdin: string, cwd?: string): Promise<GitResult> {
+	const proc: Subprocess = Bun.spawn(["git", ...args], {
+		cwd: cwd ?? process.cwd(),
+		stdin: "pipe",
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+
+	await writeStdin(proc.stdin, stdin);
+
+	const [stdout, stderr, exitCode] = await Promise.all([
+		readStream(proc.stdout as ReadableStream<Uint8Array>),
+		readStream(proc.stderr as ReadableStream<Uint8Array>),
+		proc.exited,
+	]);
+
+	return { code: exitCode ?? 0, stdout, stderr };
+}
+
+/**
+ * Get repository root directory.
+ * @throws Error if not in a git repository
+ */
+export async function getRepoRoot(cwd?: string): Promise<string> {
+	const result = await git(["rev-parse", "--show-toplevel"], cwd ?? process.cwd());
+	if (result.code !== 0) {
+		throw new WorktreeError("Not a git repository", WorktreeErrorCode.NOT_GIT_REPO);
+	}
+	const root = result.stdout.trim();
+	if (!root) {
+		throw new WorktreeError("Not a git repository", WorktreeErrorCode.NOT_GIT_REPO);
+	}
+	return path.resolve(root);
+}
+
+/**
+ * Get repository name (directory basename of repo root).
+ */
+export async function getRepoName(cwd?: string): Promise<string> {
+	const root = await getRepoRoot(cwd);
+	return path.basename(root);
+}

package/src/lib/worktree/index.ts

@@ -0,0 +1,23 @@
+export { type CollapseOptions, type CollapseResult, type CollapseStrategy, collapse } from "./collapse";
+export { WORKTREE_BASE } from "./constants";
+export { WorktreeError, WorktreeErrorCode } from "./errors";
+export { getRepoName, getRepoRoot, git, gitWithStdin } from "./git";
+export {
+	create,
+	find,
+	list,
+	prune,
+	remove,
+	type Worktree,
+	which,
+} from "./operations";
+export {
+	cleanupSessions,
+	createSession,
+	getSession,
+	listSessions,
+	type SessionStatus,
+	updateSession,
+	type WorktreeSession,
+} from "./session";
+export { formatStats, getStats, type WorktreeStats } from "./stats";