tarsk 0.4.4 → 0.4.6

package/dist/tools/index.js

@@ -1,110 +0,0 @@
-/**
- * Coding tools for the Pi agent (read, bash, edit, write, grep, find, ls).
- * Mirrors pi-mono-main/packages/coding-agent/src/core/tools.
- */
-import { bashTool, createBashTool } from "./bash.js";
-import { createEditTool, editTool } from "./edit.js";
-import { createFindTool, findTool } from "./find.js";
-import { createGrepTool, grepTool } from "./grep.js";
-import { createAstGrepTool, astGrepTool } from "./ast-grep.js";
-import { createLsTool, lsTool } from "./ls.js";
-import { createReadTool, readTool } from "./read.js";
-import { createWriteTool, writeTool } from "./write.js";
-import { createSkillScriptTool } from "./skill-tool.js";
-import { createSkillReferenceTool } from "./skill-reference-tool.js";
-import { askUserTool, createAskUserTool } from "./ask-user.js";
-import { createTodoTool, todoTool } from "./todo.js";
-import { createMCPTools } from "./mcp-tools.js";
-/** Default tools for full access (read, bash, edit, write, ask_user, todo) - using process.cwd() */
-export const codingTools = [
-    readTool,
-    bashTool,
-    editTool,
-    writeTool,
-    askUserTool,
-    todoTool,
-    findTool,
-    astGrepTool,
-];
-/** Read-only tools (read, grep, find, ls) - using process.cwd() */
-export const readOnlyTools = [readTool, grepTool, astGrepTool, findTool, lsTool];
-/** All tools by name - using process.cwd() */
-export const allTools = {
-    read: readTool,
-    bash: bashTool,
-    edit: editTool,
-    write: writeTool,
-    grep: grepTool,
-    ast_grep: astGrepTool,
-    find: findTool,
-    ls: lsTool,
-    ask_user: askUserTool,
-};
-/**
- * Create coding tools (read, bash, edit, write) configured for a specific working directory.
- * Optionally includes skill tools if skills are provided.
- * Optionally includes MCP tools if project path is provided.
- */
-export async function createCodingTools(cwd, options) {
-    const baseTools = [
-        createReadTool(cwd, options?.read),
-        createBashTool(cwd, options?.bash),
-        createEditTool(cwd),
-        createWriteTool(cwd),
-        createAskUserTool(),
-        createTodoTool(options?.threadId ?? ""),
-        createFindTool(cwd),
-        createAstGrepTool(cwd),
-    ];
-    // Add skill tools if skills are provided
-    const toolsWithSkills = [...baseTools];
-    if (options?.skills && options.skills.length > 0) {
-        const skillTools = [
-            createSkillScriptTool(options.skills, cwd),
-            createSkillReferenceTool(options.skills),
-        ];
-        toolsWithSkills.push(...skillTools);
-    }
-    // Add MCP tools if we have a project path
-    try {
-        const mcpTools = await createMCPTools(cwd);
-        toolsWithSkills.push(...mcpTools);
-    }
-    catch (error) {
-        console.warn(`[Tools] Failed to load MCP tools for ${cwd}:`, error);
-    }
-    return toolsWithSkills;
-}
-/**
- * Create read-only tools configured for a specific working directory.
- */
-export function createReadOnlyTools(cwd, options) {
-    return [
-        createReadTool(cwd, options?.read),
-        createGrepTool(cwd),
-        createFindTool(cwd),
-        createAstGrepTool(cwd),
-        createLsTool(cwd),
-    ];
-}
-/**
- * Create all tools configured for a specific working directory.
- */
-export function createAllTools(cwd, options) {
-    return {
-        read: createReadTool(cwd, options?.read),
-        bash: createBashTool(cwd, options?.bash),
-        edit: createEditTool(cwd),
-        write: createWriteTool(cwd),
-        grep: createGrepTool(cwd),
-        ast_grep: createAstGrepTool(cwd),
-        find: createFindTool(cwd),
-        ask_user: createAskUserTool(),
-        ls: createLsTool(cwd),
-    };
-}
-// Re-export skill tool functions for direct use
-export { createSkillScriptTool, listSkillScripts } from "./skill-tool.js";
-export { createSkillReferenceTool, listSkillReferences } from "./skill-reference-tool.js";
-export { createAskUserTool, submitAnswer, cancelPendingQuestion } from "./ask-user.js";
-//# sourceMappingURL=index.js.map

package/dist/tools/ls.d.ts

@@ -1,31 +0,0 @@
-import type { AgentTool } from "@mariozechner/pi-agent-core";
-import { type Static } from "@sinclair/typebox";
-import { type TruncationResult } from "./truncate.js";
-declare const lsSchema: import("@sinclair/typebox").TObject<{
-    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-}>;
-export type LsToolInput = Static<typeof lsSchema>;
-export interface LsToolDetails {
-    truncation?: TruncationResult;
-    entryLimitReached?: number;
-}
-export interface LsOperations {
-    exists: (absolutePath: string) => Promise<boolean> | boolean;
-    stat: (absolutePath: string) => Promise<{
-        isDirectory: () => boolean;
-    }> | {
-        isDirectory: () => boolean;
-    };
-    readdir: (absolutePath: string) => Promise<string[]> | string[];
-}
-export interface LsToolOptions {
-    operations?: LsOperations;
-}
-export declare function createLsTool(cwd: string, options?: LsToolOptions): AgentTool<typeof lsSchema>;
-export declare const lsTool: AgentTool<import("@sinclair/typebox").TObject<{
-    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-}>, any>;
-export {};
-//# sourceMappingURL=ls.d.ts.map

package/dist/tools/ls.js

@@ -1,108 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import { existsSync, readdirSync, statSync } from "fs";
-import nodePath from "path";
-import { resolveToCwd, validatePathWithinCwd } from "./path-utils.js";
-import { DEFAULT_MAX_BYTES, formatSize, truncateHead } from "./truncate.js";
-const lsSchema = Type.Object({
-    path: Type.Optional(Type.String({ description: "Directory to list (default: current directory)" })),
-    limit: Type.Optional(Type.Number({ description: "Maximum number of entries to return (default: 500)" })),
-});
-const DEFAULT_LIMIT = 500;
-const defaultLsOperations = {
-    exists: existsSync,
-    stat: statSync,
-    readdir: readdirSync,
-};
-export function createLsTool(cwd, options) {
-    const ops = options?.operations ?? defaultLsOperations;
-    return {
-        name: "ls",
-        label: "ls",
-        description: `List directory contents. Returns entries sorted alphabetically, with '/' suffix for directories. Output truncated to ${DEFAULT_LIMIT} entries or ${DEFAULT_MAX_BYTES / 1024}KB.`,
-        parameters: lsSchema,
-        execute: async (_toolCallId, { path: dirPathArg, limit }, signal) => {
-            return new Promise((resolve, reject) => {
-                if (signal?.aborted) {
-                    reject(new Error("Operation aborted"));
-                    return;
-                }
-                const onAbort = () => reject(new Error("Operation aborted"));
-                signal?.addEventListener("abort", onAbort, { once: true });
-                void (async () => {
-                    try {
-                        const dirPath = resolveToCwd(dirPathArg ?? ".", cwd);
-                        validatePathWithinCwd(dirPath, cwd);
-                        const effectiveLimit = limit ?? DEFAULT_LIMIT;
-                        if (!(await ops.exists(dirPath))) {
-                            reject(new Error(`Path not found: ${dirPath}`));
-                            return;
-                        }
-                        const stat = await ops.stat(dirPath);
-                        if (!stat.isDirectory()) {
-                            reject(new Error(`Not a directory: ${dirPath}`));
-                            return;
-                        }
-                        let entries;
-                        try {
-                            entries = await ops.readdir(dirPath);
-                        }
-                        catch (e) {
-                            reject(new Error(`Cannot read directory: ${e instanceof Error ? e.message : String(e)}`));
-                            return;
-                        }
-                        entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
-                        const results = [];
-                        let entryLimitReached = false;
-                        for (const entry of entries) {
-                            if (results.length >= effectiveLimit) {
-                                entryLimitReached = true;
-                                break;
-                            }
-                            const fullPath = nodePath.join(dirPath, entry);
-                            try {
-                                const entryStat = await ops.stat(fullPath);
-                                results.push(entry + (entryStat.isDirectory() ? "/" : ""));
-                            }
-                            catch {
-                                continue;
-                            }
-                        }
-                        signal?.removeEventListener("abort", onAbort);
-                        if (results.length === 0) {
-                            resolve({
-                                content: [{ type: "text", text: "(empty directory)" }],
-                                details: undefined,
-                            });
-                            return;
-                        }
-                        const rawOutput = results.join("\n");
-                        const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
-                        let output = truncation.content;
-                        const details = {};
-                        const notices = [];
-                        if (entryLimitReached) {
-                            notices.push(`${effectiveLimit} entries limit reached. Use limit=${effectiveLimit * 2} for more`);
-                            details.entryLimitReached = effectiveLimit;
-                        }
-                        if (truncation.truncated) {
-                            notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
-                            details.truncation = truncation;
-                        }
-                        if (notices.length > 0)
-                            output += `\n\n[${notices.join(". ")}]`;
-                        resolve({
-                            content: [{ type: "text", text: output }],
-                            details: Object.keys(details).length > 0 ? details : undefined,
-                        });
-                    }
-                    catch (e) {
-                        signal?.removeEventListener("abort", onAbort);
-                        reject(e);
-                    }
-                })();
-            });
-        },
-    };
-}
-export const lsTool = createLsTool(process.cwd());
-//# sourceMappingURL=ls.js.map

package/dist/tools/mcp-tools.d.ts

@@ -1,31 +0,0 @@
-/**
- * MCP Tools integration
- *
- * This file provides MCP tool integration for the Pi Agent,
- * converting MCP tools into Pi Agent compatible tools.
- */
-import type { AgentTool } from "@mariozechner/pi-agent-core";
-/**
- * Create MCP tools for a given project path
- * @param projectPath - Path to the project directory
- * @returns Promise resolving to array of MCP tools
- */
-export declare function createMCPTools(projectPath: string): Promise<AgentTool<any>[]>;
-/**
- * Get MCP tool names for a project
- * @param projectPath - Path to the project directory
- * @returns Promise resolving to array of tool names
- */
-export declare function getMCPToolNames(projectPath: string): Promise<string[]>;
-/**
- * Check if MCP tools are available for a project
- * @param projectPath - Path to the project directory
- * @returns Promise resolving to true if MCP tools are available
- */
-export declare function hasMCPTools(projectPath: string): Promise<boolean>;
-/**
- * Clear MCP tool cache for a project
- * @param projectPath - Path to the project directory
- */
-export declare function clearMCPToolCache(projectPath: string): void;
-//# sourceMappingURL=mcp-tools.d.ts.map

package/dist/tools/mcp-tools.js

@@ -1,59 +0,0 @@
-/**
- * MCP Tools integration
- *
- * This file provides MCP tool integration for the Pi Agent,
- * converting MCP tools into Pi Agent compatible tools.
- */
-import { MCPManagerImpl } from "../features/mcp/mcp.manager.js";
-/**
- * Create MCP tools for a given project path
- * @param projectPath - Path to the project directory
- * @returns Promise resolving to array of MCP tools
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export async function createMCPTools(projectPath) {
-    const mcpManager = new MCPManagerImpl();
-    try {
-        const mcpTools = await mcpManager.createToolWrappers(projectPath);
-        console.log(`[MCP Tools] Created ${mcpTools.length} MCP tools for project: ${projectPath}`);
-        return mcpTools;
-    }
-    catch (error) {
-        console.error(`[MCP Tools] Failed to create MCP tools for project ${projectPath}:`, error);
-        return [];
-    }
-}
-/**
- * Get MCP tool names for a project
- * @param projectPath - Path to the project directory
- * @returns Promise resolving to array of tool names
- */
-export async function getMCPToolNames(projectPath) {
-    const mcpManager = new MCPManagerImpl();
-    try {
-        const mcpTools = await mcpManager.getTools(projectPath);
-        return mcpTools.map((tool) => tool.name);
-    }
-    catch (error) {
-        console.error(`[MCP Tools] Failed to get MCP tool names for project ${projectPath}:`, error);
-        return [];
-    }
-}
-/**
- * Check if MCP tools are available for a project
- * @param projectPath - Path to the project directory
- * @returns Promise resolving to true if MCP tools are available
- */
-export async function hasMCPTools(projectPath) {
-    const toolNames = await getMCPToolNames(projectPath);
-    return toolNames.length > 0;
-}
-/**
- * Clear MCP tool cache for a project
- * @param projectPath - Path to the project directory
- */
-export function clearMCPToolCache(projectPath) {
-    const mcpManager = new MCPManagerImpl();
-    mcpManager.clearCache(projectPath);
-}
-//# sourceMappingURL=mcp-tools.js.map

package/dist/tools/path-utils.d.ts

@@ -1,14 +0,0 @@
-export declare function expandPath(filePath: string): string;
-/**
- * Resolve a path relative to the given cwd.
- * Handles ~ expansion and absolute paths.
- */
-export declare function resolveToCwd(filePath: string, cwd: string): string;
-/**
- * Validates that a resolved path is within the allowed cwd directory.
- * Prevents directory traversal attacks and access to files outside the project.
- * @throws Error if the path is outside the cwd
- */
-export declare function validatePathWithinCwd(resolvedPath: string, cwd: string): void;
-export declare function resolveReadPath(filePath: string, cwd: string): string;
-//# sourceMappingURL=path-utils.d.ts.map

package/dist/tools/path-utils.js

@@ -1,87 +0,0 @@
-import { accessSync, constants } from "node:fs";
-import * as os from "node:os";
-import { isAbsolute, resolve as resolvePath, relative } from "node:path";
-const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
-const NARROW_NO_BREAK_SPACE = "\u202F";
-function normalizeUnicodeSpaces(str) {
-    return str.replace(UNICODE_SPACES, " ");
-}
-function tryMacOSScreenshotPath(filePath) {
-    return filePath.replace(/ (AM|PM)\./g, `${NARROW_NO_BREAK_SPACE}$1.`);
-}
-function tryNFDVariant(filePath) {
-    return filePath.normalize("NFD");
-}
-function tryCurlyQuoteVariant(filePath) {
-    return filePath.replace(/'/g, "\u2019");
-}
-function fileExists(filePath) {
-    try {
-        accessSync(filePath, constants.F_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function normalizeAtPrefix(filePath) {
-    return filePath.startsWith("@") ? filePath.slice(1) : filePath;
-}
-export function expandPath(filePath) {
-    const normalized = normalizeUnicodeSpaces(normalizeAtPrefix(filePath));
-    if (normalized === "~") {
-        return os.homedir();
-    }
-    if (normalized.startsWith("~/")) {
-        return os.homedir() + normalized.slice(1);
-    }
-    return normalized;
-}
-/**
- * Resolve a path relative to the given cwd.
- * Handles ~ expansion and absolute paths.
- */
-export function resolveToCwd(filePath, cwd) {
-    const expanded = expandPath(filePath);
-    if (isAbsolute(expanded)) {
-        return expanded;
-    }
-    return resolvePath(cwd, expanded);
-}
-/**
- * Validates that a resolved path is within the allowed cwd directory.
- * Prevents directory traversal attacks and access to files outside the project.
- * @throws Error if the path is outside the cwd
- */
-export function validatePathWithinCwd(resolvedPath, cwd) {
-    const relativePath = relative(cwd, resolvedPath);
-    // If relative path starts with "..", it's outside the cwd
-    if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
-        throw new Error(`Access denied: Path is outside the allowed directory. ` +
-            `Requested: ${resolvedPath}, Allowed root: ${cwd}`);
-    }
-}
-export function resolveReadPath(filePath, cwd) {
-    const resolved = resolveToCwd(filePath, cwd);
-    if (fileExists(resolved)) {
-        return resolved;
-    }
-    const amPmVariant = tryMacOSScreenshotPath(resolved);
-    if (amPmVariant !== resolved && fileExists(amPmVariant)) {
-        return amPmVariant;
-    }
-    const nfdVariant = tryNFDVariant(resolved);
-    if (nfdVariant !== resolved && fileExists(nfdVariant)) {
-        return nfdVariant;
-    }
-    const curlyVariant = tryCurlyQuoteVariant(resolved);
-    if (curlyVariant !== resolved && fileExists(curlyVariant)) {
-        return curlyVariant;
-    }
-    const nfdCurlyVariant = tryCurlyQuoteVariant(nfdVariant);
-    if (nfdCurlyVariant !== resolved && fileExists(nfdCurlyVariant)) {
-        return nfdCurlyVariant;
-    }
-    return resolved;
-}
-//# sourceMappingURL=path-utils.js.map

package/dist/tools/read.d.ts

@@ -1,27 +0,0 @@
-import type { AgentTool } from "@mariozechner/pi-agent-core";
-import { type Static } from "@sinclair/typebox";
-import { type TruncationResult } from "./truncate.js";
-declare const readSchema: import("@sinclair/typebox").TObject<{
-    path: import("@sinclair/typebox").TString;
-    offset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-}>;
-export type ReadToolInput = Static<typeof readSchema>;
-export interface ReadToolDetails {
-    truncation?: TruncationResult;
-}
-export interface ReadOperations {
-    readFile: (absolutePath: string) => Promise<Buffer>;
-    access: (absolutePath: string) => Promise<void>;
-}
-export interface ReadToolOptions {
-    operations?: ReadOperations;
-}
-export declare function createReadTool(cwd: string, options?: ReadToolOptions): AgentTool<typeof readSchema>;
-export declare const readTool: AgentTool<import("@sinclair/typebox").TObject<{
-    path: import("@sinclair/typebox").TString;
-    offset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-}>, any>;
-export {};
-//# sourceMappingURL=read.d.ts.map

package/dist/tools/read.js

@@ -1,86 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import { constants } from "fs";
-import { access as fsAccess, readFile as fsReadFile } from "fs/promises";
-import { resolveReadPath, validatePathWithinCwd } from "./path-utils.js";
-import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead, } from "./truncate.js";
-import { withAbortSignal } from "./tool-helpers.js";
-const readSchema = Type.Object({
-    path: Type.String({ description: "Path to the file to read (relative or absolute)" }),
-    offset: Type.Optional(Type.Number({ description: "Line number to start reading from (1-indexed)" })),
-    limit: Type.Optional(Type.Number({ description: "Maximum number of lines to read" })),
-});
-const defaultReadOperations = {
-    readFile: (path) => fsReadFile(path),
-    access: (path) => fsAccess(path, constants.R_OK),
-};
-export function createReadTool(cwd, options) {
-    const ops = options?.operations ?? defaultReadOperations;
-    return {
-        name: "read",
-        label: "read",
-        description: `Read the contents of a text file. Output is truncated to ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). Use offset/limit for large files.`,
-        parameters: readSchema,
-        execute: async (_toolCallId, { path, offset, limit }, signal) => {
-            const absolutePath = resolveReadPath(path, cwd);
-            validatePathWithinCwd(absolutePath, cwd);
-            return withAbortSignal(signal, async (isAborted) => {
-                await ops.access(absolutePath);
-                if (isAborted())
-                    return { content: [], details: undefined };
-                const buffer = await ops.readFile(absolutePath);
-                const textContent = buffer.toString("utf-8");
-                const allLines = textContent.split("\n");
-                const totalFileLines = allLines.length;
-                const startLine = offset ? Math.max(0, offset - 1) : 0;
-                const startLineDisplay = startLine + 1;
-                if (startLine >= allLines.length) {
-                    throw new Error(`Offset ${offset} is beyond end of file (${allLines.length} lines total)`);
-                }
-                let selectedContent;
-                let userLimitedLines;
-                if (limit !== undefined) {
-                    const endLine = Math.min(startLine + limit, allLines.length);
-                    selectedContent = allLines.slice(startLine, endLine).join("\n");
-                    userLimitedLines = endLine - startLine;
-                }
-                else {
-                    selectedContent = allLines.slice(startLine).join("\n");
-                }
-                const truncation = truncateHead(selectedContent);
-                let outputText;
-                let details;
-                if (truncation.firstLineExceedsLimit) {
-                    outputText = `[Line ${startLineDisplay} is ${formatSize(Buffer.byteLength(allLines[startLine], "utf-8"))}, exceeds ${formatSize(DEFAULT_MAX_BYTES)} limit. Use bash: sed -n '${startLineDisplay}p' ${path} | head -c ${DEFAULT_MAX_BYTES}]`;
-                    details = { truncation };
-                }
-                else if (truncation.truncated) {
-                    const endLineDisplay = startLineDisplay + truncation.outputLines - 1;
-                    const nextOffset = endLineDisplay + 1;
-                    outputText = truncation.content;
-                    if (truncation.truncatedBy === "lines") {
-                        outputText += `\n\n[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use offset=${nextOffset} to continue.]`;
-                    }
-                    else {
-                        outputText += `\n\n[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Use offset=${nextOffset} to continue.]`;
-                    }
-                    details = { truncation };
-                }
-                else if (userLimitedLines !== undefined &&
-                    startLine + userLimitedLines < allLines.length) {
-                    const remaining = allLines.length - (startLine + userLimitedLines);
-                    const nextOffset = startLine + userLimitedLines + 1;
-                    outputText = truncation.content;
-                    outputText += `\n\n[${remaining} more lines in file. Use offset=${nextOffset} to continue.]`;
-                }
-                else {
-                    outputText = truncation.content;
-                }
-                if (isAborted())
-                    return { content: [], details: undefined };
-                return { content: [{ type: "text", text: outputText }], details };
-            });
-        },
-    };
-}
-export const readTool = createReadTool(process.cwd());
-//# sourceMappingURL=read.js.map

package/dist/tools/resolve-bin.d.ts

@@ -1,5 +0,0 @@
-/**
- * Resolve path to an executable on PATH. Returns the command name if found, null otherwise.
- */
-export declare function resolveBin(name: string): Promise<string | null>;
-//# sourceMappingURL=resolve-bin.d.ts.map

package/dist/tools/resolve-bin.js

@@ -1,28 +0,0 @@
-import { spawnSyncProcess } from "../core/utils.js";
-/**
- * Resolve path to an executable on PATH. Returns the command name if found, null otherwise.
- */
-export function resolveBin(name) {
-    return new Promise((resolve) => {
-        const cmd = process.platform === "win32" ? "where" : "which";
-        const args = process.platform === "win32" ? [name + ".exe", name] : [name];
-        try {
-            const result = spawnSyncProcess(cmd, args, { encoding: "utf-8", timeout: 5000 });
-            if (result.status === 0 && result.stdout) {
-                const first = (typeof result.stdout === "string" ? result.stdout : result.stdout?.toString() || "")
-                    .trim()
-                    .split(/\r?\n/)[0]
-                    ?.trim();
-                if (first) {
-                    resolve(first);
-                    return;
-                }
-            }
-        }
-        catch {
-            // ignore
-        }
-        resolve(null);
-    });
-}
-//# sourceMappingURL=resolve-bin.js.map

package/dist/tools/shell.d.ts

@@ -1,7 +0,0 @@
-export declare function getShellConfig(): {
-    shell: string;
-    args: string[];
-};
-export declare function getShellEnv(): NodeJS.ProcessEnv;
-export declare function killProcessTree(pid: number): void;
-//# sourceMappingURL=shell.d.ts.map