@bdsqqq/pi 0.0.1

package/dist/extensions/github.d.ts

@@ -0,0 +1,13 @@
+import { ExtensionAPI, ToolDefinition } from "@mariozechner/pi-coding-agent";
+
+//#region packages/extensions/github/index.d.ts
+declare function createReadGithubTool(): ToolDefinition;
+declare function createSearchGithubTool(): ToolDefinition;
+declare function createListDirectoryGithubTool(): ToolDefinition;
+declare function createListRepositoriesTool(): ToolDefinition;
+declare function createGlobGithubTool(): ToolDefinition;
+declare function createCommitSearchTool(): ToolDefinition;
+declare function createDiffTool(): ToolDefinition;
+declare function export_default(pi: ExtensionAPI): void;
+//#endregion
+export { createCommitSearchTool, createDiffTool, createGlobGithubTool, createListDirectoryGithubTool, createListRepositoriesTool, createReadGithubTool, createSearchGithubTool, export_default as default };

package/dist/extensions/github.js

@@ -0,0 +1,527 @@
+import { withPromptPatch } from "../core/prompt-patch.js";
+import { boxRendererWindowed, osc8Link, textSection } from "../core/box-format.js";
+import { addLineNumbers, decodeBase64Content, ghApi, parseRepoUrl, repoSlug, truncate } from "../core/github-api.js";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+//#region packages/extensions/github/index.ts
+/** collapsed: head 3 + tail 5 = 8 visual lines */
+const COLLAPSED_EXCERPTS = [{
+	focus: "head",
+	context: 3
+}, {
+	focus: "tail",
+	context: 5
+}];
+function createReadGithubTool() {
+	return {
+		name: "read_github",
+		label: "Read GitHub",
+		description: "Read the contents of a file from a GitHub repository.\n\nWHEN TO USE THIS TOOL:\n- When you need to examine the contents of a specific file in a remote repo\n- When you want to understand implementation details across repositories\n\nPARAMETERS:\n- path: The file path to read\n- repository: Repository URL (e.g., https://github.com/owner/repo)\n- read_range: Optional [start_line, end_line] to read only specific lines",
+		parameters: Type.Object({
+			path: Type.String({ description: "The path to the file to read" }),
+			repository: Type.String({ description: "Repository URL (e.g., https://github.com/owner/repo)" }),
+			read_range: Type.Optional(Type.Array(Type.Number(), {
+				minItems: 2,
+				maxItems: 2,
+				description: "Optional [start_line, end_line] to read only specific lines"
+			}))
+		}),
+		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const p = params;
+			try {
+				const ref = parseRepoUrl(p.repository);
+				const data = ghApi(`repos/${repoSlug(ref)}/contents/${p.path}`);
+				if (Array.isArray(data)) throw new Error("Path is a directory, not a file. Use list_directory_github instead.");
+				if (data.type !== "file" || !data.content) throw new Error(`Not a file: ${data.type}`);
+				let content = decodeBase64Content(data.content);
+				if (p.read_range) {
+					const [start, end] = p.read_range;
+					const lines = content.split("\n");
+					const startIdx = Math.max(0, start - 1);
+					const endIdx = Math.min(lines.length, end);
+					content = lines.slice(startIdx, endIdx).join("\n");
+					return {
+						content: [{
+							type: "text",
+							text: addLineNumbers(content, start)
+						}],
+						details: { header: `${repoSlug(ref)}/${p.path}` }
+					};
+				}
+				return {
+					content: [{
+						type: "text",
+						text: truncate(addLineNumbers(content), 64e3)
+					}],
+					details: { header: `${repoSlug(ref)}/${p.path}` }
+				};
+			} catch (e) {
+				throw new Error(e.message);
+			}
+		},
+		renderCall(args, theme) {
+			const path = args.path || "...";
+			const display = `${args.repository ? args.repository.replace(/^https?:\/\/github\.com\//, "") : ""}/${path}`;
+			const url = args.repository ? `${args.repository.replace(/\/$/, "")}/blob/HEAD/${path}` : "";
+			const linked = url ? osc8Link(url, display) : display;
+			return new Text(theme.fg("toolTitle", theme.bold("read_github ")) + theme.fg("dim", linked), 0, 0);
+		},
+		renderResult(result, { expanded }, _theme) {
+			const content = result.content?.[0];
+			if (!content || content.type !== "text") return new Text("(no output)", 0, 0);
+			const section = { blocks: [{ lines: content.text.split("\n").map((line) => {
+				const m = line.match(/^(\s*\d+): (.*)$/);
+				if (m && m[1] && m[2]) return {
+					gutter: m[1].trim(),
+					text: m[2],
+					highlight: true
+				};
+				return {
+					text: line,
+					highlight: true
+				};
+			}) }] };
+			return boxRendererWindowed(() => [section], {
+				collapsed: { excerpts: COLLAPSED_EXCERPTS },
+				expanded: {}
+			}, void 0, expanded);
+		}
+	};
+}
+function createSearchGithubTool() {
+	return {
+		name: "search_github",
+		label: "Search GitHub",
+		description: "Search for code patterns and content in a GitHub repository.\n\nWHEN TO USE THIS TOOL:\n- When you need to find code patterns across a repository\n- When you want to understand how functionality is implemented\n\nSupports GitHub search qualifiers (language:, path:, extension:, etc.).",
+		parameters: Type.Object({
+			pattern: Type.String({ description: "The search pattern. Supports GitHub search operators (AND, OR, NOT) and qualifiers." }),
+			repository: Type.String({ description: "Repository URL (e.g., https://github.com/owner/repo)" }),
+			path: Type.Optional(Type.String({ description: "Optional path to limit search to" })),
+			limit: Type.Optional(Type.Number({
+				description: "Max results (default: 30, max: 100)",
+				minimum: 1,
+				maximum: 100
+			})),
+			offset: Type.Optional(Type.Number({
+				description: "Results to skip for pagination (default: 0)",
+				minimum: 0
+			}))
+		}),
+		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const p = params;
+			try {
+				const ref = parseRepoUrl(p.repository);
+				const limit = p.limit ?? 30;
+				const page = p.offset ? Math.floor(p.offset / limit) + 1 : 1;
+				let query = `${p.pattern} repo:${repoSlug(ref)}`;
+				if (p.path) query += ` path:${p.path}`;
+				const data = ghApi(`search/code`, {
+					params: {
+						q: query,
+						per_page: Math.min(limit, 100),
+						page
+					},
+					accept: "application/vnd.github.text-match+json"
+				});
+				if (!data.items || data.items.length === 0) return {
+					content: [{
+						type: "text",
+						text: `No results for "${p.pattern}" in ${repoSlug(ref)}`
+					}],
+					details: { header: `/${p.pattern}/ in ${repoSlug(ref)}` }
+				};
+				const results = [`Found ${data.total_count} results (showing ${data.items.length}):\n`];
+				for (const item of data.items) {
+					results.push(`## ${item.path}`);
+					if (item.text_matches) {
+						for (const match of item.text_matches) if (match.fragment) {
+							results.push("```");
+							results.push(match.fragment);
+							results.push("```");
+						}
+					}
+					results.push("");
+				}
+				return {
+					content: [{
+						type: "text",
+						text: truncate(results.join("\n"), 64e3)
+					}],
+					details: { header: `/${p.pattern}/ in ${repoSlug(ref)}` }
+				};
+			} catch (e) {
+				throw new Error(e.message);
+			}
+		},
+		renderCall(args, theme) {
+			const pattern = args.pattern || "...";
+			const repo = args.repository ? args.repository.replace(/^https?:\/\/github\.com\//, "") : "";
+			const linkedRepo = args.repository ? osc8Link(args.repository, repo) : repo;
+			return new Text(theme.fg("toolTitle", theme.bold("search_github ")) + theme.fg("dim", `/${pattern}/ in ${linkedRepo}`), 0, 0);
+		},
+		renderResult(result, { expanded }, _theme) {
+			const content = result.content?.[0];
+			if (!content || content.type !== "text") return new Text("(no output)", 0, 0);
+			return boxRendererWindowed(() => [textSection(void 0, content.text)], {
+				collapsed: { excerpts: COLLAPSED_EXCERPTS },
+				expanded: {}
+			}, void 0, expanded);
+		}
+	};
+}
+function createListDirectoryGithubTool() {
+	return {
+		name: "list_directory_github",
+		label: "List Directory GitHub",
+		description: "List the contents of a directory in a GitHub repository.\n\nWHEN TO USE THIS TOOL:\n- When you need to understand the structure of a directory\n- When exploring a codebase to find relevant files\n\nReturns files and directories with trailing / for directories.",
+		parameters: Type.Object({
+			path: Type.String({ description: "The directory path to list (defaults to root)" }),
+			repository: Type.String({ description: "Repository URL (e.g., https://github.com/owner/repo)" }),
+			limit: Type.Optional(Type.Number({
+				description: "Max entries (default: 100, max: 1000)",
+				minimum: 1,
+				maximum: 1e3
+			}))
+		}),
+		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const p = params;
+			try {
+				const ref = parseRepoUrl(p.repository);
+				const limit = p.limit ?? 100;
+				const apiPath = p.path === "" || p.path === "." || p.path === "/" ? "" : p.path;
+				const data = ghApi(`repos/${repoSlug(ref)}/contents/${apiPath}`);
+				if (!Array.isArray(data)) throw new Error("Path is a file, not a directory. Use read_github instead.");
+				return {
+					content: [{
+						type: "text",
+						text: data.slice(0, limit).map((item) => {
+							const suffix = item.type === "dir" ? "/" : "";
+							const size = item.type === "file" && item.size ? ` (${item.size} bytes)` : "";
+							return `${item.name}${suffix}${size}`;
+						}).join("\n")
+					}],
+					details: { header: `${repoSlug(ref)}/${p.path}` }
+				};
+			} catch (e) {
+				throw new Error(e.message);
+			}
+		},
+		renderCall(args, theme) {
+			const path = args.path || "/";
+			const display = `${args.repository ? args.repository.replace(/^https?:\/\/github\.com\//, "") : ""}/${path}`;
+			const url = args.repository ? `${args.repository.replace(/\/$/, "")}/tree/HEAD/${path}` : "";
+			const linked = url ? osc8Link(url, display) : display;
+			return new Text(theme.fg("toolTitle", theme.bold("list_directory_github ")) + theme.fg("dim", linked), 0, 0);
+		},
+		renderResult(result, { expanded }, _theme) {
+			const content = result.content?.[0];
+			if (!content || content.type !== "text") return new Text("(no output)", 0, 0);
+			return boxRendererWindowed(() => [textSection(void 0, content.text)], {
+				collapsed: { excerpts: COLLAPSED_EXCERPTS },
+				expanded: {}
+			}, void 0, expanded);
+		}
+	};
+}
+function createListRepositoriesTool() {
+	return {
+		name: "list_repositories",
+		label: "List Repositories",
+		description: "List and search for repositories on GitHub.\n\nWHEN TO USE THIS TOOL:\n- When you need to find repositories by name\n- When exploring repositories in an organization\n- When you need repository metadata (stars, forks, descriptions)\n\nPrioritizes your own repositories, then supplements with public results.",
+		parameters: Type.Object({
+			pattern: Type.Optional(Type.String({ description: "Pattern to match in repository names" })),
+			organization: Type.Optional(Type.String({ description: "Organization name to filter" })),
+			language: Type.Optional(Type.String({ description: "Programming language to filter" })),
+			limit: Type.Optional(Type.Number({
+				description: "Max results (default: 30, max: 100)",
+				minimum: 1,
+				maximum: 100
+			})),
+			offset: Type.Optional(Type.Number({
+				description: "Results to skip (default: 0)",
+				minimum: 0
+			}))
+		}),
+		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const p = params;
+			try {
+				const limit = p.limit ?? 30;
+				const page = p.offset ? Math.floor(p.offset / limit) + 1 : 1;
+				const queryParts = [];
+				if (p.pattern) queryParts.push(p.pattern);
+				if (p.organization) queryParts.push(`org:${p.organization}`);
+				if (p.language) queryParts.push(`language:${p.language}`);
+				if (queryParts.length === 0) queryParts.push("stars:>0");
+				const data = ghApi("search/repositories", { params: {
+					q: queryParts.join(" "),
+					sort: "stars",
+					per_page: Math.min(limit, 100),
+					page
+				} });
+				if (!data.items || data.items.length === 0) return {
+					content: [{
+						type: "text",
+						text: "No repositories found."
+					}],
+					details: { header: queryParts.join(" ") || "repositories" }
+				};
+				const lines = [`Found ${data.total_count} repositories (showing ${data.items.length}):\n`];
+				for (const repo of data.items) {
+					lines.push(`## ${repo.full_name}`);
+					if (repo.description) lines.push(repo.description);
+					const meta = [
+						repo.language,
+						`★ ${repo.stargazers_count}`,
+						`forks: ${repo.forks_count}`
+					].filter(Boolean).join(" · ");
+					lines.push(meta);
+					lines.push(`${repo.html_url}\n`);
+				}
+				return {
+					content: [{
+						type: "text",
+						text: lines.join("\n")
+					}],
+					details: { header: queryParts.join(" ") }
+				};
+			} catch (e) {
+				throw new Error(e.message);
+			}
+		},
+		renderCall(args, theme) {
+			const query = args.pattern || args.organization || "...";
+			return new Text(theme.fg("toolTitle", theme.bold("list_repositories ")) + theme.fg("dim", query), 0, 0);
+		},
+		renderResult(result, { expanded }, _theme) {
+			const content = result.content?.[0];
+			if (!content || content.type !== "text") return new Text("(no output)", 0, 0);
+			return boxRendererWindowed(() => [textSection(void 0, content.text)], {
+				collapsed: { excerpts: COLLAPSED_EXCERPTS },
+				expanded: {}
+			}, void 0, expanded);
+		}
+	};
+}
+function createGlobGithubTool() {
+	return {
+		name: "glob_github",
+		label: "Glob GitHub",
+		description: "Find files matching a glob pattern in a GitHub repository.\n\nWHEN TO USE THIS TOOL:\n- When you need to find specific file types (e.g., all TypeScript files)\n- When exploring codebase structure quickly\n\nUses the git tree API to list all files, then filters by pattern.",
+		parameters: Type.Object({
+			filePattern: Type.String({ description: "Glob pattern (e.g., \"**/*.ts\", \"src/**/*.test.js\")" }),
+			repository: Type.String({ description: "Repository URL (e.g., https://github.com/owner/repo)" }),
+			limit: Type.Optional(Type.Number({ description: "Max results (default: 100)" })),
+			offset: Type.Optional(Type.Number({ description: "Results to skip (default: 0)" }))
+		}),
+		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const p = params;
+			try {
+				const ref = parseRepoUrl(p.repository);
+				const limit = p.limit ?? 100;
+				const offset = p.offset ?? 0;
+				const branch = ghApi(`repos/${repoSlug(ref)}`).default_branch || "main";
+				const tree = ghApi(`repos/${repoSlug(ref)}/git/trees/${branch}?recursive=1`);
+				if (!tree.tree) throw new Error("Could not read repository tree.");
+				const pattern = p.filePattern;
+				const files = tree.tree.filter((item) => item.type === "blob").map((item) => item.path).filter((path) => matchGlob(path, pattern));
+				const total = files.length;
+				const sliced = files.slice(offset, offset + limit);
+				return {
+					content: [{
+						type: "text",
+						text: [
+							`Found ${total} files matching "${pattern}" (showing ${sliced.length}):`,
+							"",
+							...sliced
+						].join("\n")
+					}],
+					details: { header: `${p.filePattern} in ${repoSlug(ref)}` }
+				};
+			} catch (e) {
+				throw new Error(e.message);
+			}
+		},
+		renderCall(args, theme) {
+			const pattern = args.filePattern || "...";
+			const repo = args.repository ? args.repository.replace(/^https?:\/\/github\.com\//, "") : "";
+			const linkedRepo = args.repository ? osc8Link(args.repository, repo) : repo;
+			return new Text(theme.fg("toolTitle", theme.bold("glob_github ")) + theme.fg("dim", `${pattern} in ${linkedRepo}`), 0, 0);
+		},
+		renderResult(result, { expanded }, _theme) {
+			const content = result.content?.[0];
+			if (!content || content.type !== "text") return new Text("(no output)", 0, 0);
+			return boxRendererWindowed(() => [textSection(void 0, content.text)], {
+				collapsed: { excerpts: COLLAPSED_EXCERPTS },
+				expanded: {}
+			}, void 0, expanded);
+		}
+	};
+}
+function createCommitSearchTool() {
+	return {
+		name: "commit_search",
+		label: "Commit Search",
+		description: "Search commit history in a GitHub repository.\n\nWHEN TO USE THIS TOOL:\n- When you need to understand how code evolved over time\n- When looking for commits by a specific author or date range\n- When finding commits that changed specific files",
+		parameters: Type.Object({
+			repository: Type.String({ description: "Repository URL (e.g., https://github.com/owner/repo)" }),
+			query: Type.Optional(Type.String({ description: "Search query for commit messages" })),
+			author: Type.Optional(Type.String({ description: "Filter by author username or email" })),
+			since: Type.Optional(Type.String({ description: "ISO 8601 date for earliest commit (e.g., \"2024-01-01T00:00:00Z\")" })),
+			until: Type.Optional(Type.String({ description: "ISO 8601 date for latest commit (e.g., \"2024-02-01T00:00:00Z\")" })),
+			path: Type.Optional(Type.String({ description: "Filter commits that changed specific files/directories" })),
+			limit: Type.Optional(Type.Number({
+				description: "Max commits (default: 50, max: 100)",
+				minimum: 1,
+				maximum: 100
+			})),
+			offset: Type.Optional(Type.Number({
+				description: "Commits to skip (default: 0)",
+				minimum: 0
+			}))
+		}),
+		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const p = params;
+			try {
+				const ref = parseRepoUrl(p.repository);
+				const limit = p.limit ?? 50;
+				const page = p.offset ? Math.floor(p.offset / limit) + 1 : 1;
+				const apiParams = {
+					per_page: Math.min(limit, 100),
+					page
+				};
+				if (p.author) apiParams.author = p.author;
+				if (p.since) apiParams.since = p.since;
+				if (p.until) apiParams.until = p.until;
+				let endpoint = `repos/${repoSlug(ref)}/commits`;
+				if (p.path) apiParams.path = p.path;
+				const commits = ghApi(endpoint, { params: apiParams });
+				if (!Array.isArray(commits) || commits.length === 0) return {
+					content: [{
+						type: "text",
+						text: "No commits found."
+					}],
+					details: { header: repoSlug(ref) }
+				};
+				let filtered = commits;
+				if (p.query) {
+					const q = p.query.toLowerCase();
+					filtered = commits.filter((c) => c.commit?.message?.toLowerCase().includes(q));
+				}
+				const lines = [`Found ${filtered.length} commits:\n`];
+				for (const c of filtered) {
+					const sha = c.sha?.slice(0, 7) ?? "???????";
+					const author = c.commit?.author?.name ?? c.author?.login ?? "unknown";
+					const date = c.commit?.author?.date ?? "";
+					const msg = c.commit?.message?.split("\n")[0] ?? "";
+					lines.push(`${sha} ${date} (${author}) ${msg}`);
+				}
+				return {
+					content: [{
+						type: "text",
+						text: lines.join("\n")
+					}],
+					details: { header: repoSlug(ref) }
+				};
+			} catch (e) {
+				throw new Error(e.message);
+			}
+		},
+		renderCall(args, theme) {
+			const repo = args.repository ? args.repository.replace(/^https?:\/\/github\.com\//, "") : "...";
+			const linkedRepo = args.repository ? osc8Link(args.repository, repo) : repo;
+			const query = args.query || args.author || "";
+			return new Text(theme.fg("toolTitle", theme.bold("commit_search ")) + theme.fg("dim", `${linkedRepo} ${query}`.trim()), 0, 0);
+		},
+		renderResult(result, { expanded }, _theme) {
+			const content = result.content?.[0];
+			if (!content || content.type !== "text") return new Text("(no output)", 0, 0);
+			return boxRendererWindowed(() => [textSection(void 0, content.text)], {
+				collapsed: { excerpts: COLLAPSED_EXCERPTS },
+				expanded: {}
+			}, void 0, expanded);
+		}
+	};
+}
+function createDiffTool() {
+	return {
+		name: "diff",
+		label: "Diff",
+		description: "Get a diff between two commits, branches, or tags in a GitHub repository.\n\nWHEN TO USE THIS TOOL:\n- When you need to see what changed between two points in history\n- When reviewing changes across branches\n- When understanding the scope of a release",
+		parameters: Type.Object({
+			base: Type.String({ description: "The base ref to compare from (e.g., \"main\", \"v1.0.0\", or commit SHA)" }),
+			head: Type.String({ description: "The head ref to compare to (e.g., \"feature-branch\", \"v2.0.0\", or commit SHA)" }),
+			repository: Type.String({ description: "Repository URL (e.g., https://github.com/owner/repo)" }),
+			includePatches: Type.Optional(Type.Boolean({ description: "Include unified diff patches per file (token heavy). Default false." }))
+		}),
+		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const p = params;
+			try {
+				const data = ghApi(`repos/${repoSlug(parseRepoUrl(p.repository))}/compare/${encodeURIComponent(p.base)}...${encodeURIComponent(p.head)}`);
+				const lines = [
+					`Comparing ${p.base}...${p.head}`,
+					`Status: ${data.status}`,
+					`Ahead by: ${data.ahead_by} commits`,
+					`Behind by: ${data.behind_by} commits`,
+					`Changed files: ${data.files?.length ?? 0}`,
+					""
+				];
+				if (data.files) for (const file of data.files) {
+					const stat = `+${file.additions} -${file.deletions}`;
+					lines.push(`${file.status} ${file.filename} (${stat})`);
+					if (p.includePatches && file.patch) {
+						lines.push("```diff");
+						lines.push(truncate(file.patch, 4e3));
+						lines.push("```");
+						lines.push("");
+					}
+				}
+				return {
+					content: [{
+						type: "text",
+						text: truncate(lines.join("\n"), 64e3)
+					}],
+					details: { header: `${p.base}...${p.head}` }
+				};
+			} catch (e) {
+				throw new Error(e.message);
+			}
+		},
+		renderCall(args, theme) {
+			const repo = args.repository ? args.repository.replace(/^https?:\/\/github\.com\//, "") : "...";
+			const linkedRepo = args.repository ? osc8Link(args.repository, repo) : repo;
+			const range = `${args.base || "?"}...${args.head || "?"}`;
+			return new Text(theme.fg("toolTitle", theme.bold("diff ")) + theme.fg("dim", `${linkedRepo} ${range}`), 0, 0);
+		},
+		renderResult(result, { expanded }, _theme) {
+			const content = result.content?.[0];
+			if (!content || content.type !== "text") return new Text("(no output)", 0, 0);
+			return boxRendererWindowed(() => [textSection(void 0, content.text)], {
+				collapsed: { excerpts: COLLAPSED_EXCERPTS },
+				expanded: {}
+			}, void 0, expanded);
+		}
+	};
+}
+/**
+* simple glob matcher. supports:
+*   ** (any path segments), * (any within segment), ? (single char)
+*/
+function matchGlob(path, pattern) {
+	const regexStr = pattern.replace(/\./g, "\\.").replace(/\*\*\//g, "(.+/)?").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]");
+	try {
+		return new RegExp(`^${regexStr}$`).test(path);
+	} catch {
+		return path.includes(pattern.replace(/[*?]/g, ""));
+	}
+}
+function github_default(pi) {
+	pi.registerTool(withPromptPatch(createReadGithubTool()));
+	pi.registerTool(withPromptPatch(createSearchGithubTool()));
+	pi.registerTool(withPromptPatch(createListDirectoryGithubTool()));
+	pi.registerTool(withPromptPatch(createListRepositoriesTool()));
+	pi.registerTool(withPromptPatch(createGlobGithubTool()));
+	pi.registerTool(withPromptPatch(createCommitSearchTool()));
+	pi.registerTool(withPromptPatch(createDiffTool()));
+}
+//#endregion
+export { createCommitSearchTool, createDiffTool, createGlobGithubTool, createListDirectoryGithubTool, createListRepositoriesTool, createReadGithubTool, createSearchGithubTool, github_default as default };

package/dist/extensions/glob.d.ts

@@ -0,0 +1,10 @@
+import { ExtensionAPI, ToolDefinition } from "@mariozechner/pi-coding-agent";
+
+//#region packages/extensions/glob/index.d.ts
+type GlobExtConfig = {
+  defaultLimit: number;
+};
+declare function createGlobTool(config?: GlobExtConfig): ToolDefinition;
+declare function export_default(pi: ExtensionAPI): void;
+//#endregion
+export { createGlobTool, export_default as default };