@yofriadi/pi-ast 0.1.0 → 0.1.1

package/README.md

@@ -1,4 +1,22 @@
 # AST Extension
+## Install from git URL
+
+```bash
+pi install git:github.com/yofriadi/pi-extensions@ast-v<version>
+```
+
+To load only this extension from the monorepo package source, use package filtering in settings:
+
+```json
+{
+  "packages": [
+    {
+      "source": "git:github.com/yofriadi/pi-extensions@ast-v<version>",
+      "extensions": ["packages/ast/src/index.ts"]
+    }
+  ]
+}
+```
 
 This extension provides integration with `ast-grep` (sg).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yofriadi/pi-ast",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "keywords": [
     "pi-package",
@@ -16,6 +16,12 @@
     "build": "echo 'nothing to build'"
   },
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*"
-  }
+    "@mariozechner/pi-coding-agent": "^0.52.10"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yofriadi/pi-extensions.git",
+    "directory": "packages/ast"
+  },
+  "homepage": "https://github.com/yofriadi/pi-extensions/tree/main/packages/ast"
 }

package/src/index.ts

@@ -1,8 +1,8 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-import { registerAstSearch } from "./tools/ast-search";
-import { registerAstRewrite } from "./tools/ast-rewrite";
-import { exec } from "./utils/exec";
+import { registerAstRewrite } from "./tools/ast-rewrite.js";
+import { registerAstSearch } from "./tools/ast-search.js";
+import { exec } from "./utils/exec.js";
 
 export default function astExtension(pi: ExtensionAPI): void {
 	// Register tools
@@ -17,21 +17,24 @@ export default function astExtension(pi: ExtensionAPI): void {
 		execute: async () => {
 			try {
 				const { exitCode, stdout, stderr } = await exec(["sg", "--version"]);
-				
+
 				if (exitCode !== 0) {
-					 return {
-						 content: [{ type: "text", text: `ast-grep (sg) check failed: ${stderr}` }],
-						 isError: true
-					 }
+					return {
+						content: [{ type: "text", text: `ast-grep (sg) check failed: ${stderr}` }],
+						isError: true,
+						details: undefined,
+					};
 				}
 
 				return {
 					content: [{ type: "text", text: `ast-grep (sg) is available: ${stdout.trim()}` }],
+					details: undefined,
 				};
 			} catch (error) {
 				return {
-						content: [{ type: "text", text: `ast-grep (sg) check failed: ${(error as Error).message}` }],
-						isError: true
+					content: [{ type: "text", text: `ast-grep (sg) check failed: ${(error as Error).message}` }],
+					isError: true,
+					details: undefined,
 				};
 			}
 		},

package/src/tools/ast-rewrite.ts

@@ -1,6 +1,6 @@
-import { Type } from "@sinclair/typebox";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { exec } from "../utils/exec";
+import { Type } from "@sinclair/typebox";
+import { exec } from "../utils/exec.js";
 
 const MAX_OUTPUT_LENGTH = 10000;
 
@@ -8,7 +8,8 @@ export function registerAstRewrite(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "ast_rewrite",
 		label: "AST Rewrite",
-		description: "Search and rewrite code using AST patterns with ast-grep (sg). Defaults to dry-run (preview). Use `apply: true` to execute changes.",
+		description:
+			"Search and rewrite code using AST patterns with ast-grep (sg). Defaults to dry-run (preview). Use `apply: true` to execute changes.",
 		parameters: Type.Object({
 			pattern: Type.String({ description: "AST pattern to search for" }),
 			rewrite: Type.String({ description: "Replacement pattern" }),
@@ -21,49 +22,52 @@ export function registerAstRewrite(pi: ExtensionAPI): void {
 
 			try {
 				const args = ["sg", "run", "--pattern", pattern, "--rewrite", rewrite, "--color=never"];
-				
+
 				if (lang) {
 					args.push("--lang", lang);
 				}
-				
+
 				if (apply) {
 					args.push("-U"); // Update all (apply)
 				}
-				
+
 				// Add path at the end
 				if (path) {
 					args.push(path);
 				}
 
 				const { exitCode, stdout, stderr } = await exec(args);
-				
+
 				if (exitCode !== 0) {
-					 return {
-						 content: [{ type: "text", text: `ast-rewrite failed: ${stderr}` }],
-						 isError: true
-					 }
+					return {
+						content: [{ type: "text", text: `ast-rewrite failed: ${stderr}` }],
+						isError: true,
+						details: undefined,
+					};
 				}
 
 				if (!stdout.trim()) {
-					 return {
-						 content: [{ type: "text", text: apply ? "No changes applied (no matches found)." : "No matches found." }],
-					 };
+					return {
+						content: [{ type: "text", text: apply ? "No changes applied (no matches found)." : "No matches found." }],
+						details: undefined,
+					};
 				}
 
 				let output = stdout;
 				if (output.length > MAX_OUTPUT_LENGTH) {
-					output = output.substring(0, MAX_OUTPUT_LENGTH) + "\n... (truncated)";
+					output = `${output.substring(0, MAX_OUTPUT_LENGTH)}\n... (truncated)`;
 				}
 
 				const mode = apply ? "APPLIED" : "DRY-RUN (preview)";
 				return {
 					content: [{ type: "text", text: `[${mode}]\n\n${output}` }],
+					details: undefined,
 				};
-
 			} catch (error) {
 				return {
-						content: [{ type: "text", text: `ast-rewrite execution error: ${(error as Error).message}` }],
-						isError: true
+					content: [{ type: "text", text: `ast-rewrite execution error: ${(error as Error).message}` }],
+					isError: true,
+					details: undefined,
 				};
 			}
 		},

package/src/tools/ast-search.ts

@@ -1,9 +1,18 @@
-import { Type } from "@sinclair/typebox";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { exec } from "../utils/exec";
+import { Type } from "@sinclair/typebox";
+import { exec } from "../utils/exec.js";
 
 const MAX_OUTPUT_LENGTH = 10000;
 
+interface SgMatch {
+	file: string;
+	range: {
+		start: { line: number };
+		end: { line: number };
+	};
+	text: string;
+}
+
 export function registerAstSearch(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "ast_search",
@@ -25,42 +34,49 @@ export function registerAstSearch(pi: ExtensionAPI): void {
 				}
 
 				const { exitCode, stdout, stderr } = await exec(args);
-				
+
 				if (exitCode !== 0) {
-					 // sg returns non-zero if no matches? No, usually 0 even if no matches.
-					 // But if it fails to parse pattern, it returns non-zero.
-					 return {
-						 content: [{ type: "text", text: `ast-search failed: ${stderr}` }],
-						 isError: true
-					 }
+					// sg returns non-zero if no matches? No, usually 0 even if no matches.
+					// But if it fails to parse pattern, it returns non-zero.
+					return {
+						content: [{ type: "text", text: `ast-search failed: ${stderr}` }],
+						isError: true,
+						details: undefined,
+					};
 				}
 
 				if (!stdout.trim()) {
 					return {
 						content: [{ type: "text", text: "No matches found." }],
+						details: undefined,
 					};
 				}
 
-				let results;
+				let results: SgMatch[];
 				try {
 					results = JSON.parse(stdout);
 				} catch (e) {
 					return {
-						content: [{ type: "text", text: `Failed to parse ast-search output: ${(e as Error).message}\nOutput: ${stdout}` }],
-						isError: true
+						content: [
+							{ type: "text", text: `Failed to parse ast-search output: ${(e as Error).message}\nOutput: ${stdout}` },
+						],
+						isError: true,
+						details: undefined,
 					};
 				}
 
 				if (!Array.isArray(results)) {
-					 return {
+					return {
 						content: [{ type: "text", text: `Unexpected output format from ast-search: ${stdout}` }],
-						isError: true
+						isError: true,
+						details: undefined,
 					};
 				}
 
 				if (results.length === 0) {
 					return {
 						content: [{ type: "text", text: "No matches found." }],
+						details: undefined,
 					};
 				}
 
@@ -70,22 +86,23 @@ export function registerAstSearch(pi: ExtensionAPI): void {
 					const startLine = match.range.start.line + 1;
 					const endLine = match.range.end.line + 1;
 					const text = match.text;
-					
+
 					output += `${file}:${startLine}-${endLine}:\n${text}\n\n`;
 				}
-				
+
 				if (output.length > MAX_OUTPUT_LENGTH) {
-					output = output.substring(0, MAX_OUTPUT_LENGTH) + "\n... (truncated)";
+					output = `${output.substring(0, MAX_OUTPUT_LENGTH)}\n... (truncated)`;
 				}
 
 				return {
 					content: [{ type: "text", text: output.trim() }],
+					details: undefined,
 				};
-
 			} catch (error) {
 				return {
-						content: [{ type: "text", text: `ast-search execution error: ${(error as Error).message}` }],
-						isError: true
+					content: [{ type: "text", text: `ast-search execution error: ${(error as Error).message}` }],
+					isError: true,
+					details: undefined,
 				};
 			}
 		},

package/src/utils/exec.ts

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { join, resolve } from "node:path";
 
 export interface ExecResult {
 	stdout: string;
@@ -6,20 +7,61 @@ export interface ExecResult {
 	exitCode: number;
 }
 
+interface BunProcess {
+	exited: Promise<number>;
+	stdout: ReadableStream<Uint8Array>;
+	stderr: ReadableStream<Uint8Array>;
+}
+
+interface BunInterface {
+	spawn: (
+		command: string[],
+		options: {
+			cwd?: string;
+			env?: Record<string, string | undefined>;
+			stdout?: "pipe";
+			stderr?: "pipe";
+		},
+	) => BunProcess;
+}
+
 export async function exec(command: string[], options: { cwd?: string } = {}): Promise<ExecResult> {
+	// Add node_modules/.bin to PATH
+	const env = { ...process.env };
+	const cwd = options.cwd ?? process.cwd();
+
+	// Try to find the closest node_modules/.bin
+	let currentDir = cwd;
+	const binPaths: string[] = [];
+	while (true) {
+		binPaths.push(join(currentDir, "node_modules", ".bin"));
+		const parentDir = resolve(currentDir, "..");
+		if (parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
+
+	const pathSeparator = process.platform === "win32" ? ";" : ":";
+	const existingPath = env.PATH ?? "";
+	env.PATH = [existingPath, ...binPaths].filter((value) => value && value.length > 0).join(pathSeparator);
+
 	// Try Bun first
-	const bun = (globalThis as any).Bun;
+	const bun = (globalThis as Record<string, unknown>).Bun as BunInterface | undefined;
 	if (bun && typeof bun.spawn === "function") {
-		return execBun(bun, command, options);
+		return execBun(bun, command, { ...options, env });
 	}
 
 	// Fallback to Node
-	return execNode(command, options);
+	return execNode(command, { ...options, env });
 }
 
-async function execBun(bun: any, command: string[], options: { cwd?: string }): Promise<ExecResult> {
+async function execBun(
+	bun: BunInterface,
+	command: string[],
+	options: { cwd?: string; env?: Record<string, string | undefined> },
+): Promise<ExecResult> {
 	const proc = bun.spawn(command, {
 		cwd: options.cwd,
+		env: options.env,
 		stdout: "pipe",
 		stderr: "pipe",
 	});
@@ -31,11 +73,15 @@ async function execBun(bun: any, command: string[], options: { cwd?: string }):
 	return { stdout, stderr, exitCode };
 }
 
-function execNode(command: string[], options: { cwd?: string }): Promise<ExecResult> {
+function execNode(
+	command: string[],
+	options: { cwd?: string; env?: Record<string, string | undefined> },
+): Promise<ExecResult> {
 	return new Promise((resolve, reject) => {
 		const [cmd, ...args] = command;
 		const child = spawn(cmd, args, {
 			cwd: options.cwd,
+			env: options.env,
 			stdio: ["ignore", "pipe", "pipe"],
 		});
 

package/test/fixtures/example.ts

@@ -1,3 +1,3 @@
-function hello(name: string) {
-  console.log("Hello, " + name);
+function _hello(name: string) {
+	console.log(`Hello, ${name}`);
 }

package/test/integration.test.ts

@@ -1,11 +1,11 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { registerAstSearch } from '../src/tools/ast-search';
-import { registerAstRewrite } from '../src/tools/ast-rewrite';
-import type { ExtensionAPI, ToolDefinition } from '@mariozechner/pi-coding-agent';
-import { join } from 'path';
+import { join } from "node:path";
+import type { ExtensionAPI, ToolDefinition } from "@mariozechner/pi-coding-agent";
+import { beforeEach, describe, expect, it } from "vitest";
+import { registerAstRewrite } from "../src/tools/ast-rewrite.js";
+import { registerAstSearch } from "../src/tools/ast-search.js";
 
 // Using Bun-compatible dirname
-const fixturesDir = join(import.meta.dirname, 'fixtures');
+const fixturesDir = join(import.meta.dirname, "fixtures");
 
 // Mock ExtensionAPI
 const createMockPi = () => {
@@ -14,89 +14,95 @@ const createMockPi = () => {
 		registerTool: (tool: ToolDefinition) => {
 			tools[tool.name] = tool;
 		},
-		tools
+		tools,
 	};
 };
 
-describe('AST Extension Integration', () => {
+describe("AST Extension Integration", () => {
 	let mockPi: ReturnType<typeof createMockPi>;
 
 	beforeEach(() => {
 		mockPi = createMockPi();
 	});
 
-	describe('ast_search', () => {
-		it('should find patterns in TypeScript', async () => {
+	describe("ast_search", () => {
+		it("should find patterns in TypeScript", async () => {
 			// Register tool
 			registerAstSearch(mockPi as unknown as ExtensionAPI);
-			const tool = mockPi.tools['ast_search'];
+			const tool = mockPi.tools.ast_search;
 			expect(tool).toBeDefined();
 
 			// Execute tool
 			const params = {
-				pattern: 'console.log($A)',
-				path: join(fixturesDir, 'example.ts'),
-				lang: 'typescript'
+				pattern: "console.log($A)",
+				path: join(fixturesDir, "example.ts"),
+				lang: "typescript",
 			};
-			
+
 			// Mock context and other args
-			const result = await tool.execute('test-id', params, undefined, undefined, {} as any);
-			
-			expect(result.isError).toBeFalsy();
-			
-			const content = result.content[0].text;
+			// biome-ignore lint/suspicious/noExplicitAny: Mocking tool result
+			const result = (await tool.execute("test-id", params, undefined, undefined, {} as unknown as any)) as any;
+
+			expect(result.isError, result.content[0]?.type === "text" ? result.content[0].text : undefined).toBeFalsy();
+
+			const content = result.content[0]?.type === "text" ? result.content[0].text : "";
 			// Should verify output format
-			expect(content).toContain('example.ts');
+			expect(content).toContain("example.ts");
 			// AST grep output usually includes line numbers
 			// e.g. "example.ts:2-2:\n  console.log(\"Hello, \" + name);"
-			
+
 			// Just verify matched text is present
-			expect(content).toContain('console.log("Hello, " + name)');
+			// biome-ignore lint/suspicious/noTemplateCurlyInString: Testing for literal string in output
+			expect(content).toContain("console.log(`Hello, ${name}`)");
 		});
 
-		it('should find patterns in Rust', async () => {
+		it("should find patterns in Rust", async () => {
 			registerAstSearch(mockPi as unknown as ExtensionAPI);
-			const tool = mockPi.tools['ast_search'];
-			
+			const tool = mockPi.tools.ast_search;
+
 			const params = {
-				pattern: 'println!($A, $B)',
-				path: join(fixturesDir, 'example.rs'),
-				lang: 'rust'
+				pattern: "println!($A, $B)",
+				path: join(fixturesDir, "example.rs"),
+				lang: "rust",
 			};
-			
-			const result = await tool.execute('test-id', params, undefined, undefined, {} as any);
-			
-			expect(result.isError).toBeFalsy();
-			const content = result.content[0].text;
+
+			// biome-ignore lint/suspicious/noExplicitAny: Mocking tool result
+			const result = (await tool.execute("test-id", params, undefined, undefined, {} as unknown as any)) as any;
+
+			expect(result.isError, result.content[0]?.type === "text" ? result.content[0].text : undefined).toBeFalsy();
+			const content = result.content[0]?.type === "text" ? result.content[0].text : "";
 			expect(content).toContain('println!("Hello, {}", name)');
 		});
 	});
 
-	describe('ast_rewrite', () => {
-		it('should dry-run rewrite in TypeScript', async () => {
+	describe("ast_rewrite", () => {
+		it("should dry-run rewrite in TypeScript", async () => {
 			registerAstRewrite(mockPi as unknown as ExtensionAPI);
-			const tool = mockPi.tools['ast_rewrite'];
+			const tool = mockPi.tools.ast_rewrite;
 			expect(tool).toBeDefined();
 
 			const params = {
-				pattern: 'console.log($A)',
-				rewrite: 'logger.info($A)',
-				path: join(fixturesDir, 'example.ts'),
-				lang: 'typescript',
-				apply: false
+				pattern: "console.log($A)",
+				rewrite: "logger.info($A)",
+				path: join(fixturesDir, "example.ts"),
+				lang: "typescript",
+				apply: false,
 			};
-			
-			const result = await tool.execute('test-id', params, undefined, undefined, {} as any);
-			
-			expect(result.isError).toBeFalsy();
-			const content = result.content[0].text;
-			
-			expect(content).toContain('[DRY-RUN (preview)]');
+
+			// biome-ignore lint/suspicious/noExplicitAny: Mocking tool result
+			const result = (await tool.execute("test-id", params, undefined, undefined, {} as unknown as any)) as any;
+
+			expect(result.isError, result.content[0]?.type === "text" ? result.content[0].text : undefined).toBeFalsy();
+			const content = result.content[0]?.type === "text" ? result.content[0].text : "";
+
+			expect(content).toContain("[DRY-RUN (preview)]");
 			// Verify diff output
 			// sg output usually has @@ ... @@
 			// and -old +new lines
-			expect(content).toContain('-  console.log("Hello, " + name);');
-			expect(content).toContain('+  logger.info("Hello, " + name);');
+			// biome-ignore lint/suspicious/noTemplateCurlyInString: Testing for literal string in output
+			expect(content).toContain("console.log(`Hello, ${name}`);");
+			// biome-ignore lint/suspicious/noTemplateCurlyInString: Testing for literal string in output
+			expect(content).toContain("logger.info(`Hello, ${name}`);");
 		});
 	});
 });