pi-smart-reader 0.1.0

package/README.md

@@ -0,0 +1,77 @@
+# pi-smart-reader 🔍
+
+A structural code analysis extension for [Pi](https://pi.dev/) that eliminates "token bloat" by providing skeletal views and targeted symbol extraction.
+
+[![Pi Package](https://img.shields.io/badge/Pi-Package-blue)](https://pi.dev/packages)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![npm version](https://img.shields.io/npm/v/pi-smart-reader.svg)](https://www.npmjs.com/package/pi-smart-reader)
+
+## 🚩 The Problem
+Reading entire files is the most expensive operation for an AI agent. In large codebases, loading a 2,000-line file just to understand a single function:
+- **Wastes Tokens**: Consumes a huge portion of the context window.
+- **Dilutes Attention**: Buries the "signal" in a sea of "noise," leading to hallucinations or missed details.
+- **Increases Cost**: Significantly raises the token count per request.
+
+## ✨ The Solution
+`pi-smart-reader` replaces blind reading with **Structural Extraction**. Instead of reading the whole file, the agent can now "skim" the API and surgically extract only the necessary logic.
+
+## 🚀 Features
+
+### 1. Skeleton View (`mode: "skeleton"`)
+Generates a high-level map of the file. It preserves all class and function signatures but strips the implementation bodies.
+- **Example**: 2,000 lines of code $\to$ 50 lines of API signatures.
+- **Benefit**: Allows the agent to understand the file's capabilities without loading the whole content.
+
+### 2. Targeted Symbol Extraction (`mode: "symbol"`)
+Extracts the exact source code for a specific function, method, or variable.
+- **Precision**: Uses AST (Abstract Syntax Tree) parsing to find the precise byte range of the symbol.
+- **Efficiency**: Loads only the required logic into the context.
+
+### 3. Dependency Awareness
+When extracting a symbol, the sentinel scans the function body for calls to other symbols within the same file and suggests them as related dependencies.
+
+## 🛠️ Installation
+
+```bash
+pi install npm:pi-smart-reader
+```
+
+## 📖 Quick Start
+
+The extension adds the `smart_read` tool to your agent.
+
+### Step 1: Get the Skeleton
+Instead of `read(path)`, use:
+```json
+{
+  "tool": "smart_read",
+  "input": {
+    "path": "src/services/UserService.ts",
+    "options": { "mode": "skeleton" }
+  }
+}
+```
+*The agent now sees all available methods without the noise of their implementations.*
+
+### Step 2: Extract the Logic
+Once the agent identifies the target method (e.g., `validateToken`), it extracts it:
+```json
+{
+  "tool": "smart_read",
+  "input": {
+    "path": "src/services/UserService.ts",
+    "options": { 
+      "mode": "symbol", 
+      "symbol": "validateToken" 
+    }
+  }
+}
+```
+
+## ⚙️ Technical Details
+- **Engine**: Powered by `tree-sitter` for robust, language-aware parsing.
+- **Complexity**: $O(N)$ parsing time, but $O(1)$ context impact after extraction.
+- **Language Support**: Full support for TypeScript and JavaScript.
+
+## 📜 License
+MIT

package/benchmark.ts

@@ -0,0 +1,55 @@
+import { SmartParser } from "./src/parser";
+import { SkeletonEngine } from "./src/skeleton";
+import { SymbolExtractor } from "./src/extractor";
+import { readFileSync } from "fs";
+
+async function runBenchmark() {
+	console.log("📊 Starting pi-smart-reader Performance Benchmark...");
+
+	const parser = new SmartParser();
+	await parser.initialize({
+		wasmPath:
+			"https://github.com/tree-sitter/tree-sitter-wasm/releases/download/v0.20.0/tree-sitter.wasm",
+		languagePath:
+			"https://github.com/tree-sitter/tree-sitter-typescript/releases/download/v0.20.0/tree-sitter-typescript.wasm",
+	});
+
+	const skeletonEngine = new SkeletonEngine(parser);
+	const symbolExtractor = new SymbolExtractor(parser);
+
+	const filePath = "benchmark_file.ts";
+	const source = readFileSync(filePath, "utf8");
+	const fullSize = source.length;
+
+	console.log(`\nFile: ${filePath}`);
+	console.log(`Full File Size: ${fullSize} characters`);
+
+	// 1. Test Skeleton
+	const skeleton = skeletonEngine.generateSkeleton(source);
+	const skeletonSize = skeleton.length;
+	const skeletonReduction = ((1 - skeletonSize / fullSize) * 100).toFixed(2);
+
+	console.log(`\n--- Skeleton View ---`);
+	console.log(`Skeleton Size: ${skeletonSize} characters`);
+	console.log(`Reduction: ${skeletonReduction}%`);
+
+	// 2. Test Symbol Extraction
+	const targetSymbol = "login";
+	const { content, relatedSymbols } = symbolExtractor.extractSymbol(
+		source,
+		targetSymbol,
+	);
+	const symbolSize = content.length;
+	const symbolReduction = ((1 - symbolSize / fullSize) * 100).toFixed(2);
+
+	console.log(`\n--- Symbol Extraction [${targetSymbol}] ---`);
+	console.log(`Symbol Size: ${symbolSize} characters`);
+	console.log(`Reduction: ${symbolReduction}%`);
+	console.log(`Related Symbols Found: ${relatedSymbols.join(", ") || "None"}`);
+
+	console.log(
+		`\nConclusion: pi-smart-reader reduced context from ${fullSize} to as little as ${Math.min(skeletonSize, symbolSize)} characters.`,
+	);
+}
+
+runBenchmark().catch(console.error);

package/benchmark_file.ts

@@ -0,0 +1,139 @@
+/**
+ * Benchmark file for pi-smart-reader
+ * Contains many functions to test AST extraction and token reduction.
+ */
+
+export class UserAuthService {
+	public async login(username: string, password: string): Promise<boolean> {
+		console.log("Logging in user...");
+		const user = await this.findUser(username);
+		if (!user) return false;
+		const isValid = await this.verifyPassword(password, user.hash);
+		if (isValid) {
+			const token = this.generateToken(user.id);
+			await this.logSession(user.id, token);
+			return true;
+		}
+		return false;
+	}
+
+	private async findUser(username: string): Promise<any> {
+		// Simulate DB lookup
+		return { id: "123", hash: "hashed_password" };
+	}
+
+	private async verifyPassword(
+		password: string,
+		hash: string,
+	): Promise<boolean> {
+		// Simulate password check
+		return password === "password123";
+	}
+
+	private generateToken(userId: string): string {
+		return "jwt_token_" + userId + "_" + Date.now();
+	}
+
+	private async logSession(userId: string, token: string): Promise<void> {
+		console.log(`Session started for ${userId}`);
+	}
+}
+
+export class DataProcessor {
+	public processData(data: any[]): any[] {
+		console.log("Starting data processing...");
+		const filtered = this.filterInvalid(data);
+		const mapped = this.mapToInternal(filtered);
+		const sorted = this.sortData(mapped);
+		return this.finalize(sorted);
+	}
+
+	private filterInvalid(data: any[]): any[] {
+		return data.filter((item) => item !== null && item !== undefined);
+	}
+
+	private mapToInternal(data: any[]): any[] {
+		return data.map((item) => ({ ...item, processed: true }));
+	}
+
+	private sortData(data: any[]): any[] {
+		return data.sort((a, b) => a.id - b.id);
+	}
+
+	private finalize(data: any[]): any[] {
+		console.log("Finalizing process...");
+		return data;
+	}
+}
+
+function helperUtility1() {
+	console.log("Util 1");
+	return true;
+}
+
+function helperUtility2() {
+	console.log("Util 2");
+	return false;
+}
+
+// Adding more filler functions to increase file size
+function filler1() {
+	return 1;
+}
+function filler2() {
+	return 2;
+}
+function filler3() {
+	return 3;
+}
+function filler4() {
+	return 4;
+}
+function filler5() {
+	return 5;
+}
+function filler6() {
+	return 6;
+}
+function filler7() {
+	return 7;
+}
+function filler8() {
+	return 8;
+}
+function filler9() {
+	return 9;
+}
+function filler10() {
+	return 10;
+}
+function filler11() {
+	return 11;
+}
+function filler12() {
+	return 12;
+}
+function filler13() {
+	return 13;
+}
+function filler14() {
+	return 14;
+}
+function filler15() {
+	return 15;
+}
+function filler16() {
+	return 16;
+}
+function filler17() {
+	return 17;
+}
+function filler18() {
+	return 18;
+}
+function filler19() {
+	return 19;
+}
+function filler20() {
+	return 20;
+}

package/docs/proposal.md

@@ -0,0 +1,32 @@
+# Proposal: pi-smart-reader
+
+## 1. Problem Statement
+When working with large files, AI agents typically use the `read` tool, which loads the entire file content into the conversation context. This leads to several critical issues:
+- **Token Exhaustion**: Large files quickly consume the context window, leaving less room for reasoning and output.
+- **Attention Dilution**: The "Lost in the Middle" phenomenon occurs where the model overlooks critical details buried in noise.
+- **Cost**: Higher token usage increases API costs.
+
+## 2. Goal
+Create a Pi extension that replaces "blind" file reading with **Structural Extraction**. The agent should be able to understand the "shape" of a file without reading its entire content, and then surgically extract only the relevant fragments of code needed for the task.
+
+## 3. Core Features
+### A. Skeleton View (`mode: "skeleton"`)
+Instead of the full file, the sentinel generates a "Skeletal" version. It strips all implementation details (function bodies, class internals) and preserves only the signatures.
+- **Example**: A 2,000-line file becomes a 50-line list of exported functions and classes.
+
+### B. Targeted Symbol Extraction (`mode: "symbol"`)
+Allows the agent to request a specific function, method, or variable by name.
+- **Precision**: Using AST (Abstract Syntax Tree) parsing, the tool extracts only the exact range of the requested symbol.
+- **Efficiency**: Only the relevant code is loaded into the context.
+
+### C. Dependency Mapping
+When extracting a symbol, the tool scans for internal calls to other functions in the same file and suggests those related symbols to the agent.
+
+## 4. Success Criteria
+- **Token Reduction**: At least a 70-90% reduction in tokens used when analyzing large files.
+- **Accuracy**: The agent must be able to identify the correct function to modify using only the Skeleton view.
+- **Language Support**: Initial support for TypeScript and JavaScript using `web-tree-sitter`.
+
+## 5. Non-Goals
+- This is not a replacement for `read` when the entire file is actually needed (e.g., for a full refactor).
+- It will not perform cross-file dependency resolution (that is the role of LSP).

package/docs/spec.md

@@ -0,0 +1,60 @@
+# Technical Specification: pi-smart-reader
+
+## 1. Architecture Overview
+`pi-smart-reader` is a Pi extension that provides a specialized tool `smart_read` which leverages AST parsing via `web-tree-sitter` to selectively extract code fragments.
+
+## 2. Detection & Extraction Logic
+
+### A. The Skeleton Engine
+The engine uses Tree-sitter queries to identify "headers" of code blocks.
+**Query Logic (TS/JS)**:
+- Find all `function_declaration`, `method_definition`, and `variable_declaration` (with arrow functions).
+- Extract the name and the parameter list.
+- Replace the body (`{ ... }`) with a comment `// ... implementation`.
+
+### B. Symbol Extraction
+When a `symbol` name is provided:
+1. The AST is scanned for a node whose identifier matches the symbol name.
+2. The `start` and `end` byte offsets of that node are identified.
+3. The original file content is sliced using these offsets.
+
+### C. Dependency Scanning
+While extracting a symbol body:
+1. The body is parsed for `call_expression` nodes.
+2. The identifiers of these calls are collected.
+3. Any identifiers that match other symbols in the same file are returned as `relatedSymbols`.
+
+## 3. Tool API Design
+
+**Tool Name**: `smart_read`
+
+**Input Schema**:
+```json
+{
+  "path": "string",
+  "options": {
+    "mode": "skeleton" | "symbol",
+    "symbol": "string (optional)",
+    "includeDependencies": "boolean (optional)"
+  }
+}
+```
+
+**Output Format**:
+- `mode: "skeleton"` $\to$ Returns the skeletal version of the file.
+- `mode: "symbol"` $\to$ Returns the code fragment and a list of related symbols.
+
+## 4. Implementation Details
+
+### A. Parser Strategy
+Use `web-tree-sitter` for WASM-based parsing.
+- **Language**: `tree-sitter-typescript` (covers JS and TS).
+- **Loading**: Load the WASM binary on extension startup.
+
+### B. Integration with Pi
+The extension registers `smart_read` as a custom tool via `pi.registerTool()`.
+
+## 5. Performance & Complexity
+- **Time Complexity**: $O(N)$ to parse the file, where $N$ is file size.
+- **Space Complexity**: $O(T)$ where $T$ is the size of the extracted fragment.
+- **Token Impact**: Moves from $O(FileSize)$ to $O(SymbolSize)$.

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "pi-smart-reader",
+  "version": "0.1.0",
+  "description": "Optimizes token usage by providing skeletal views and targeted symbol extraction for large files.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w"
+  },
+  "keywords": [
+    "pi",
+    "pi-package",
+    "context-optimization",
+    "ast",
+    "token-savings"
+  ],
+  "author": "ZachDreamZ",
+  "license": "MIT",
+  "pi": {
+    "extensions": [
+      "dist/index.js"
+    ]
+  },
+  "dependencies": {
+    "tree-sitter": "^0.21.1",
+    "tree-sitter-typescript": "^0.23.2",
+    "web-tree-sitter": "latest"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  }
+}

package/src/extractor.ts

@@ -0,0 +1,91 @@
+import type { SmartParser } from "./parser";
+import type { Node } from "web-tree-sitter";
+
+export class SymbolExtractor {
+	constructor(private parser: SmartParser) {}
+
+	/**
+	 * Extracts the full body of a specific symbol by name.
+	 */
+	public extractSymbol(
+		source: string,
+		symbolName: string,
+	): { content: string; relatedSymbols: string[] } {
+		const tree = this.parser.parse(source);
+		const root = tree.rootNode;
+
+		const targetNode = this.findSymbolNode(root, symbolName);
+
+		if (!targetNode) {
+			throw new Error(`Symbol '${symbolName}' not found in file.`);
+		}
+
+		const content = source.slice(targetNode.startIndex, targetNode.endIndex);
+		const related = this.findRelatedSymbols(targetNode, source);
+
+		return {
+			content,
+			relatedSymbols: related,
+		};
+	}
+
+	private findSymbolNode(node: Node, name: string): Node | null {
+		const findIdentifierNode = (n: Node): Node | null => {
+			if (n.type === "identifier" || n.type === "property_identifier") {
+				if (n.text === name) {
+					console.log(`Found identifier ${name} at ${n.startIndex}`);
+					return n;
+				}
+			}
+			for (const child of n.namedChildren) {
+				const found = findIdentifierNode(child);
+				if (found) return found;
+			}
+			return null;
+		};
+
+		const idNode = findIdentifierNode(node);
+		if (!idNode) {
+			console.log(`Identifier ${name} not found in AST.`);
+			return null;
+		}
+
+		let current: Node | null = idNode;
+		while (current) {
+			console.log(`Climbing: ${current.type}`);
+			if (
+				current.type === "function_declaration" ||
+				current.type === "method_definition" ||
+				current.type === "variable_declarator" ||
+				current.type === "class_declaration"
+			) {
+				console.log(`Found symbol container: ${current.type}`);
+				return current;
+			}
+			current = current.parent;
+		}
+
+		console.log(`Reached root without finding a symbol container for ${name}.`);
+		return null;
+	}
+
+	private findRelatedSymbols(node: Node, _source: string): string[] {
+		const related: string[] = [];
+
+		// Scan the subtree for call expressions
+		const walk = (n: Node) => {
+			if (n.type === "call_expression") {
+				const call = n.namedChildren.find((c) => c.type === "identifier");
+				if (call) {
+					related.push(call.text);
+				}
+			}
+			for (const child of n.namedChildren) {
+				walk(child);
+			}
+		};
+
+		walk(node);
+		return [...new Set(related)]; // Unique only
+	}
+}

package/src/index.ts

@@ -0,0 +1,90 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { SmartParser } from "./parser";
+import { SkeletonEngine } from "./skeleton";
+import { SymbolExtractor } from "./extractor";
+import { readFileSync } from "fs";
+
+export default async function (pi: ExtensionAPI) {
+	const parser = new SmartParser();
+
+	// Configuration for JS/TS (using hosted WASM for simplicity in this version)
+	const config = {
+		wasmPath:
+			"https://github.com/tree-sitter/tree-sitter-wasm/releases/download/v0.20.0/tree-sitter.wasm",
+		languagePath:
+			"https://github.com/tree-sitter/tree-sitter-typescript/releases/download/v0.20.0/tree-sitter-typescript.wasm",
+	};
+
+	await parser.initialize(config);
+	const skeletonEngine = new SkeletonEngine(parser);
+	const symbolExtractor = new SymbolExtractor(parser);
+
+	pi.registerTool({
+		name: "smart_read",
+		description:
+			"Read a file structurally. Use 'skeleton' mode to see the API of a large file, or 'symbol' mode to extract a specific function body.",
+		parameters: {
+			type: "object",
+			properties: {
+				path: { type: "string", description: "Path to the file to read" },
+				options: {
+					type: "object",
+					properties: {
+						mode: {
+							type: "string",
+							enum: ["skeleton", "symbol"],
+							description: "Extraction mode",
+						},
+						symbol: {
+							type: "string",
+							description:
+								"The name of the symbol to extract (required for 'symbol' mode)",
+						},
+					},
+					required: ["mode"],
+				},
+			},
+			required: ["path", "options"],
+		},
+		handler: async (input: any, _ctx: any) => {
+			const { path, options } = input;
+
+			try {
+				const source = readFileSync(path, "utf8");
+
+				if (options.mode === "skeleton") {
+					return {
+						content: skeletonEngine.generateSkeleton(source),
+						mode: "skeleton",
+						message:
+							"Skeletal view of the file generated. Implementation details stripped.",
+					};
+				}
+
+				if (options.mode === "symbol") {
+					if (!options.symbol) {
+						throw new Error("Symbol name is required for 'symbol' mode.");
+					}
+
+					const { content, relatedSymbols } = symbolExtractor.extractSymbol(
+						source,
+						options.symbol,
+					);
+
+					return {
+						content,
+						relatedSymbols,
+						mode: "symbol",
+						message: `Extracted symbol '${options.symbol}' and identified related dependencies.`,
+					};
+				}
+
+				throw new Error(`Unsupported mode: ${options.mode}`);
+			} catch (error: any) {
+				return {
+					error: `Failed to smart-read ${path}: ${error.message}`,
+				};
+			}
+		},
+	});
+}

package/src/parser.ts

@@ -0,0 +1,45 @@
+import Parser from "tree-sitter";
+import TypeScript from "tree-sitter-typescript";
+
+export interface ParserConfig {
+	// Not strictly needed for native tree-sitter but kept for API compatibility
+	wasmPath?: string;
+	languagePath?: string;
+}
+
+export class SmartParser {
+	private parser: Parser | null = null;
+	private language: any | null = null;
+
+	/**
+	 * Initializes the tree-sitter parser with TypeScript support.
+	 */
+	public async initialize(_config?: ParserConfig): Promise<void> {
+		try {
+			this.parser = new Parser();
+			this.language = TypeScript.typescript;
+			this.parser.setLanguage(this.language);
+		} catch (error) {
+			console.error("[pi-smart-reader] Initialization failed:", error);
+			throw new Error(`Failed to initialize tree-sitter: ${error}`);
+		}
+	}
+
+	/**
+	 * Parses the source code into an AST.
+	 */
+	public parse(source: string) {
+		if (!this.parser) {
+			throw new Error("Parser not initialized. Call initialize() first.");
+		}
+		return this.parser.parse(source);
+	}
+
+	public getLanguage() {
+		return this.language;
+	}
+
+	public isInitialized(): boolean {
+		return this.parser !== null && this.language !== null;
+	}
+}

package/src/skeleton.ts

@@ -0,0 +1,69 @@
+import type { SmartParser } from "./parser";
+import type { Node } from "web-tree-sitter";
+
+export class SkeletonEngine {
+	constructor(private parser: SmartParser) {}
+
+	/**
+	 * Generates a skeletal view of the source code.
+	 * Keeps signatures of functions and classes, but strips bodies.
+	 */
+	public generateSkeleton(source: string): string {
+		const tree = this.parser.parse(source);
+		const root = tree.rootNode;
+
+		let skeleton = "";
+		const lines = source.split("\\n");
+
+		const walkAndLog = (node: any, depth = 0) => {
+			if (node.text.includes("login")) {
+				console.log(`Depth ${depth} | Type: ${node.type} | Text: ${node.text}`);
+			}
+			for (const child of node.namedChildren) {
+				walkAndLog(child, depth + 1);
+			}
+		};
+		walkAndLog(root);
+
+		// We iterate through the top-level named children
+		for (const node of root.namedChildren) {
+			if (this.isSignatureNode(node)) {
+				skeleton += this.extractSignature(node, lines) + "\\n";
+			} else if (node.type === "comment") {
+				skeleton += node.text + "\\n";
+			}
+		}
+
+		return skeleton || "// No structural symbols found in this file.";
+	}
+
+	private isSignatureNode(node: Node): boolean {
+		const types = [
+			"function_declaration",
+			"method_definition",
+			"class_declaration",
+			"variable_declaration",
+		];
+		return types.includes(node.type);
+	}
+
+	private extractSignature(node: Node, lines: string[]): string {
+		const startLine = node.startPosition.row;
+		const endLine = node.endPosition.row;
+
+		// For signatures, we want the line where the name/params are,
+		// but we want to stop before the opening brace '{'
+		let result = "";
+		for (let i = startLine; i <= endLine; i++) {
+			const line = lines[i] || "";
+			if (line.includes("{")) {
+				result += line.split("{")[0] + " { // ... implementation";
+				break;
+			}
+			result += line + "\\n";
+		}
+
+		// Trim trailing newlines
+		return result.trimEnd();
+	}
+}

package/src/types/pi-coding-agent.d.ts

@@ -0,0 +1,18 @@
+declare module "@earendil-works/pi-coding-agent" {
+	export interface ExtensionAPI {
+		on(
+			event: string,
+			handler: (event: any, ctx: ExtensionContext) => Promise<void> | void,
+		): void;
+		registerTool(options: any): void;
+	}
+
+	export interface ExtensionContext {
+		ui: {
+			notify(
+				message: string,
+				level: "info" | "success" | "warning" | "error",
+			): void;
+		};
+	}
+}

package/src/types/web-tree-sitter.d.ts

@@ -0,0 +1,30 @@
+declare module 'web-tree-sitter' {
+	export default class Parser {
+		static async init(options: { wasmPath: string }): Promise<void>;
+		constructor();
+		setLanguage(language: any): void;
+		parse(source: string): Tree;
+
+		static Language: {
+			load(path: string): Promise<any>;
+		};
+	}
+
+	export interface Tree {
+		rootNode: Node;
+		// Simplified for this extension's needs
+	}
+
+	export interface Node {
+		id: number;
+		type: string;
+		text: string;
+		startPosition: { row: number; column: number };
+		endPosition: { row: number; column: number };
+		startIndex: number;
+		endIndex: number;
+		children: Node[];
+		parent: Node | null;
+		namedChildren: Node[];
+	}
+}

package/tasks.md

@@ -0,0 +1,29 @@
+# Implementation Tasks: pi-smart-reader
+
+## Phase 1: Foundation
+- [ ] Initialize project with `package.json` and `tsconfig.json`.
+- [ ] Setup `web-tree-sitter` WASM loader and language bindings.
+
+## Phase 2: The Skeleton Engine
+- [ ] Implement Tree-sitter queries to find function/class signatures.
+- [ ] Implement the logic to strip function bodies and replace with `// ...`.
+- [ ] Create a test suite with large TS/JS files to verify skeletal output.
+
+## Phase 3: Precision Extraction
+- [ ] Implement symbol lookup logic (mapping name $\to$ byte range).
+- [ ] Implement the content slicing mechanism.
+- [ ] Implement internal dependency scanning (finding calls within a function).
+
+## Phase 4: Pi Tool Integration
+- [ ] Define the `smart_read` tool schema.
+- [ ] Implement the `smart_read` handler in the extension.
+- [ ] Integrate the logic from Phase 2 and 3 into the handler.
+
+## Phase 5: Benchmarking & Optimization
+- [ ] Compare token usage: `read` vs `smart_read(skeleton)` vs `smart_read(symbol)`.
+- [ ] Optimize AST queries for speed.
+- [ ] Handle edge cases (anonymous functions, complex nested classes).
+
+## Phase 6: Release
+- [ ] Write professional README.md.
+- [ ] Publish to npm and GitHub.

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true
+  },
+  "include": ["src/**/*"],
+  "typeRoots": ["./node_modules/@types", "src/types"]
+}

package/wasm/tree-sitter-typescript.wasm

@@ -0,0 +1 @@
+Not Found

package/wasm/tree-sitter.wasm

@@ -0,0 +1 @@
+Not Found