min-agent 0.1.4 → 0.1.6

package/dist/skills.js

@@ -3,6 +3,7 @@ import { readFileSync, existsSync, readdirSync, statSync } from "fs";
 import os from "os";
 import path from "path";
 import { globSync } from "glob";
+import { loadConfig } from "./config.js";
 /**
  * Skill scan order: later entries win on duplicate `name` in frontmatter.
  * Global user skills first, then project-local dirs so repo skills override ~/.agents.
@@ -15,7 +16,7 @@ const SKILL_DIRS = [
     path.join(process.cwd(), ".claude", "skills"),
 ];
 let loadedSkills = {};
-export function discoverSkills() {
+export function discoverSkills(opts) {
     loadedSkills = {};
     for (const dir of SKILL_DIRS) {
         if (!existsSync(dir))
@@ -29,8 +30,10 @@ export function discoverSkills() {
         }
     }
     const count = Object.keys(loadedSkills).length;
-    if (count > 0) {
-        console.log(`\x1b[90m  Skills loaded: ${count} (${Object.keys(loadedSkills).join(", ")})\x1b[0m`);
+    if (count > 0 && !opts?.silent) {
+        const disabled = new Set(loadConfig().disabledSkills ?? []);
+        const enabledCount = Object.keys(loadedSkills).filter((n) => !disabled.has(n)).length;
+        console.log(`\x1b[90m  Skills: ${enabledCount} enabled${count > enabledCount ? `, ${count - enabledCount} disabled` : ""}\x1b[0m`);
     }
 }
 function parseSkillFile(filePath) {
@@ -58,7 +61,8 @@ function parseSkillFile(filePath) {
     }
 }
 export function getSkills() {
-    return Object.values(loadedSkills);
+    const disabled = new Set(loadConfig().disabledSkills ?? []);
+    return Object.values(loadedSkills).filter((s) => !disabled.has(s.name));
 }
 export function getSkill(name) {
     return loadedSkills[name];
@@ -74,9 +78,13 @@ export function getSkillsTool() {
             required: ["name"],
         }),
         execute: async ({ name }) => {
+            const disabled = new Set(loadConfig().disabledSkills ?? []);
+            if (disabled.has(name)) {
+                return `Skill "${name}" is disabled. Available skills: ${getSkills().map((s) => s.name).join(", ") || "none"}`;
+            }
             const skill = loadedSkills[name];
             if (!skill) {
-                const available = Object.keys(loadedSkills);
+                const available = getSkills().map((s) => s.name);
                 return `Skill "${name}" not found. Available skills: ${available.length ? available.join(", ") : "none"}`;
             }
             const dir = path.dirname(skill.location);
@@ -104,7 +112,7 @@ export function getSkillsTool() {
     });
 }
 export function getSkillsSystemPrompt() {
-    const skills = Object.values(loadedSkills);
+    const skills = getSkills();
     if (skills.length === 0)
         return "";
     return [
@@ -115,7 +123,7 @@ export function getSkillsSystemPrompt() {
     ].join("\n");
 }
 function buildSkillDescription() {
-    const skills = Object.values(loadedSkills);
+    const skills = getSkills();
     if (skills.length === 0)
         return "Load a specialized skill. No skills are currently available.";
     return [

package/dist/structured-output.js

@@ -0,0 +1,29 @@
+import { tool, jsonSchema } from "ai";
+/**
+ * Structured output support.
+ *
+ * When the user requests JSON output matching a schema, a StructuredOutput tool
+ * is injected. The model MUST call this tool to return its final answer in the
+ * requested format.
+ *
+ * Based on opencode's structured output implementation in prompt.ts.
+ */
+const STRUCTURED_OUTPUT_DESCRIPTION = `Use this tool to return your final response in the requested structured format.
+
+IMPORTANT:
+- You MUST call this tool exactly once at the end of your response
+- The input must be valid JSON matching the required schema
+- Complete all necessary research and tool calls BEFORE calling this tool
+- This tool provides your final answer - no further actions are taken after calling it`;
+export const STRUCTURED_OUTPUT_SYSTEM = `IMPORTANT: The user has requested structured output. You MUST use the StructuredOutput tool to provide your final response. Do NOT respond with plain text - you MUST call the StructuredOutput tool with your answer formatted according to the schema.`;
+export function createStructuredOutputTool(request, onSuccess) {
+    const { $schema: _, ...toolSchema } = request.schema;
+    return tool({
+        description: STRUCTURED_OUTPUT_DESCRIPTION,
+        inputSchema: jsonSchema(toolSchema),
+        execute: async (args) => {
+            onSuccess(args);
+            return JSON.stringify(args, null, 2);
+        },
+    });
+}

package/dist/title-gen.js

@@ -0,0 +1,48 @@
+import { generateText } from "ai";
+/**
+ * Auto-generate a short title for a conversation session.
+ *
+ * Based on opencode's title agent — uses the LLM to produce a concise
+ * title from the first user message and assistant response.
+ */
+const TITLE_PROMPT = `Generate a very short title (max 50 chars) for this conversation. 
+Output ONLY the title text, nothing else. No quotes, no prefix.
+The title should capture the main topic or intent.`;
+export async function generateTitle(model, messages) {
+    // Need at least one user message
+    const userMsg = messages.find((m) => m.role === "user");
+    if (!userMsg)
+        return null;
+    const userContent = typeof userMsg.content === "string"
+        ? userMsg.content
+        : Array.isArray(userMsg.content)
+            ? userMsg.content.filter((p) => "text" in p).map((p) => p.text).join(" ")
+            : "";
+    if (!userContent.trim())
+        return null;
+    // Include first assistant response if available for better context
+    const assistantMsg = messages.find((m) => m.role === "assistant");
+    const assistantContent = assistantMsg
+        ? typeof assistantMsg.content === "string"
+            ? assistantMsg.content.slice(0, 200)
+            : ""
+        : "";
+    const context = assistantContent
+        ? `User: ${userContent.slice(0, 300)}\nAssistant: ${assistantContent}`
+        : `User: ${userContent.slice(0, 300)}`;
+    try {
+        const result = await generateText({
+            model,
+            messages: [
+                { role: "system", content: TITLE_PROMPT },
+                { role: "user", content: context },
+            ],
+            temperature: 0.5,
+        });
+        const title = result.text.trim().replace(/^["']|["']$/g, "").slice(0, 60);
+        return title || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/tools/bash.js

@@ -1,72 +1,13 @@
-import { spawn } from "child_process";
 import { tool, jsonSchema } from "ai";
+import { spawn } from "child_process";
 import { confirm, isDangerousCommand, isAutoApprove } from "../confirm.js";
-import { truncateToolOutput } from "../tool-output.js";
-/** Hard cap for in-memory collection before killing the process (avoid OOM on huge stdout). */
-const COLLECT_HARD_CAP_BYTES = 16 * 1024 * 1024;
-function runCommand(command, cwd, timeoutMs) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(command, {
-            shell: true,
-            cwd,
-            env: process.env,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        const outChunks = [];
-        const errChunks = [];
-        let total = 0;
-        let killedCap = false;
-        let killedTimeout = false;
-        const timer = setTimeout(() => {
-            killedTimeout = true;
-            child.kill("SIGTERM");
-            setTimeout(() => child.kill("SIGKILL"), 2000).unref();
-        }, timeoutMs);
-        const push = (buf, arr) => {
-            total += buf.length;
-            if (total > COLLECT_HARD_CAP_BYTES && !killedCap) {
-                killedCap = true;
-                child.kill("SIGKILL");
-                return;
-            }
-            arr.push(buf);
-        };
-        child.stdout?.on("data", (b) => push(b, outChunks));
-        child.stderr?.on("data", (b) => push(b, errChunks));
-        child.on("error", (err) => {
-            clearTimeout(timer);
-            reject(err);
-        });
-        child.on("close", (code) => {
-            clearTimeout(timer);
-            const stdout = Buffer.concat(outChunks).toString("utf-8");
-            const stderr = Buffer.concat(errChunks).toString("utf-8");
-            let combined = stdout.replace(/\s+$/, "");
-            if (stderr)
-                combined += (combined ? "\n" : "") + stderr.replace(/\s+$/, "");
-            if (killedCap) {
-                combined +=
-                    `\n\n[bash] Output collection stopped: exceeded ${COLLECT_HARD_CAP_BYTES} bytes in-memory cap (process was killed). Prefer redirecting to a file (e.g. > out.txt) then read with startLine/endLine.`;
-            }
-            else if (killedTimeout) {
-                combined += `\n\n[bash] Command exceeded timeout ${timeoutMs} ms (process terminated).`;
-            }
-            resolve({
-                code,
-                output: combined || "(no output)",
-                killedByTimeout: killedTimeout,
-                killedByCap: killedCap,
-            });
-        });
-    });
-}
 export const bashTool = tool({
-    description: "Run a shell command. Use this for system operations, running builds, tests, git commands, etc. The command runs in the current working directory. Very long stdout/stderr is truncated: full output may be saved under ~/.min-agent/tool-output/ with a preview returned.",
+    description: "Run a shell command. Use this for system operations, running builds, tests, git commands, etc. The command runs in the current working directory. You SHOULD set a timeout based on how long you expect the command to take. If no timeout is set, the command runs until it finishes or the user manually interrupts (Ctrl+C).",
     inputSchema: jsonSchema({
         type: "object",
         properties: {
             command: { type: "string", description: "The shell command to execute" },
-            timeout: { type: "number", description: "Timeout in milliseconds (default: 30000)" },
+            timeout: { type: "number", description: "Timeout in milliseconds. Set based on expected duration (e.g. 5000 for quick commands, 60000 for builds). Omit only for commands with unpredictable duration." },
         },
         required: ["command"],
     }),
@@ -76,18 +17,88 @@ export const bashTool = tool({
             if (!approved)
                 return "Command rejected by user.";
         }
-        const timeoutMs = timeout ?? 30000;
-        try {
-            const { code, output, killedByTimeout, killedByCap } = await runCommand(command, process.cwd(), timeoutMs);
-            let body = output;
-            if (code !== 0 && code !== null && !killedByTimeout && !killedByCap) {
-                body = `Exit code ${code}\n${body}`;
+        return new Promise((resolve) => {
+            const chunks = [];
+            let killed = false;
+            let timer;
+            // On Windows, force UTF-8 codepage to avoid Chinese garbled text
+            const isWin = process.platform === "win32";
+            const actualCommand = isWin ? `chcp 65001 >nul && ${command}` : command;
+            const proc = spawn(actualCommand, [], {
+                shell: true,
+                cwd: process.cwd(),
+                stdio: ["ignore", "pipe", "pipe"],
+                detached: process.platform !== "win32",
+                env: { ...process.env, ...(isWin ? { PYTHONIOENCODING: "utf-8" } : {}) },
+            });
+            proc.stdout?.on("data", (chunk) => chunks.push(chunk));
+            proc.stderr?.on("data", (chunk) => chunks.push(chunk));
+            // Timeout kill (only if timeout is specified)
+            if (timeout && timeout > 0) {
+                timer = setTimeout(() => {
+                    killed = true;
+                    killProcess(proc.pid);
+                    resolve(getOutput(chunks) +
+                        `\n\n[Command timed out after ${timeout}ms and was killed. Retry with a larger timeout if needed.]`);
+                }, timeout);
             }
-            const { content } = truncateToolOutput(body, { direction: "tail" });
-            return content.trim() || "(no output)";
-        }
-        catch (err) {
-            return `Error: ${err.message ?? String(err)}`;
-        }
+            // Allow user to interrupt with Ctrl+C (SIGINT)
+            const sigintHandler = () => {
+                killed = true;
+                if (timer)
+                    clearTimeout(timer);
+                killProcess(proc.pid);
+                resolve(getOutput(chunks) + "\n\n[Command interrupted by user.]");
+            };
+            process.on("SIGINT", sigintHandler);
+            proc.on("close", (code) => {
+                process.removeListener("SIGINT", sigintHandler);
+                if (timer)
+                    clearTimeout(timer);
+                if (killed)
+                    return;
+                const output = getOutput(chunks);
+                if (code === 0) {
+                    resolve(output || "(no output)");
+                }
+                else {
+                    resolve(`Exit code ${code}\n${output || "(no output)"}`);
+                }
+            });
+            proc.on("error", (err) => {
+                process.removeListener("SIGINT", sigintHandler);
+                if (timer)
+                    clearTimeout(timer);
+                if (killed)
+                    return;
+                resolve(`Error: ${err.message}`);
+            });
+        });
     },
 });
+function getOutput(chunks) {
+    const output = Buffer.concat(chunks).toString("utf-8").trim();
+    if (output.length > 100_000) {
+        return output.slice(0, 50_000) + `\n\n...(truncated, ${output.length} bytes total)...\n\n` + output.slice(-10_000);
+    }
+    return output;
+}
+function killProcess(pid) {
+    if (!pid)
+        return;
+    try {
+        if (process.platform !== "win32") {
+            process.kill(-pid, "SIGTERM");
+            setTimeout(() => {
+                try {
+                    process.kill(-pid, "SIGKILL");
+                }
+                catch { }
+            }, 3000);
+        }
+        else {
+            process.kill(pid, "SIGTERM");
+        }
+    }
+    catch { }
+}

package/dist/tools/code_search.js

@@ -0,0 +1,91 @@
+import { tool, jsonSchema } from "ai";
+import { truncateToolOutput } from "../tool-output.js";
+const EXA_MCP_URL = process.env.EXA_API_KEY
+    ? `https://mcp.exa.ai/mcp?exaApiKey=${encodeURIComponent(process.env.EXA_API_KEY)}`
+    : "https://mcp.exa.ai/mcp";
+export const codeSearchTool = tool({
+    description: `Search and get relevant context for any programming task using Exa Code API.
+Provides high-quality, fresh context for libraries, SDKs, and APIs.
+Use this for ANY question or task related to programming — finding code examples, documentation, API references, and patterns.
+
+Usage:
+- Adjustable token count (1000-50000) for focused or comprehensive results
+- Default 5000 tokens for balanced context
+- Examples: 'React useState hook examples', 'Python pandas dataframe filtering', 'Express.js middleware', 'Rust async trait implementation'`,
+    inputSchema: jsonSchema({
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "Search query for APIs, libraries, SDKs. E.g. 'React useState hook examples', 'Express.js middleware'",
+            },
+            tokensNum: {
+                type: "number",
+                description: "Number of tokens to return (1000-50000). Default 5000. Use lower for focused queries, higher for comprehensive docs.",
+            },
+        },
+        required: ["query"],
+    }),
+    execute: async ({ query, tokensNum }) => {
+        const tokens = Math.max(1000, Math.min(50000, tokensNum ?? 5000));
+        try {
+            const result = await callExaCode(query, tokens);
+            if (!result) {
+                return "No code snippets or documentation found. Try a different query, be more specific about the library or concept, or check spelling.";
+            }
+            return truncateToolOutput(result, { direction: "head" }).content;
+        }
+        catch (err) {
+            return `Code search error: ${err.message}`;
+        }
+    },
+});
+/**
+ * Call Exa's MCP endpoint for code context.
+ * Uses JSON-RPC over HTTP with SSE response format.
+ */
+async function callExaCode(query, tokensNum) {
+    const body = JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: {
+            name: "get_code_context_exa",
+            arguments: { query, tokensNum },
+        },
+    });
+    const response = await fetch(EXA_MCP_URL, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json, text/event-stream",
+        },
+        body,
+        signal: AbortSignal.timeout(30000),
+    });
+    if (!response.ok) {
+        throw new Error(`Exa API returned ${response.status}`);
+    }
+    const text = await response.text();
+    // Parse SSE response: look for "data: {...}" lines
+    for (const line of text.split("\n")) {
+        if (!line.startsWith("data: "))
+            continue;
+        try {
+            const data = JSON.parse(line.slice(6));
+            const content = data?.result?.content?.[0]?.text;
+            if (content)
+                return content;
+        }
+        catch { }
+    }
+    // Try parsing as direct JSON response
+    try {
+        const data = JSON.parse(text);
+        const content = data?.result?.content?.[0]?.text;
+        if (content)
+            return content;
+    }
+    catch { }
+    return null;
+}

package/dist/tools/explore.js

@@ -0,0 +1,104 @@
+import { tool, jsonSchema, streamText, stepCountIs } from "ai";
+import { resolveModel } from "../provider.js";
+import { bashTool } from "./bash.js";
+import { readTool } from "./read.js";
+import { globTool } from "./glob.js";
+import { grepTool } from "./grep.js";
+import { stripThinkingFromAssistantText } from "../assistant-stream.js";
+import { truncateToolOutput } from "../tool-output.js";
+const EXPLORE_SYSTEM = `You are a file search specialist. You excel at thoroughly navigating and exploring codebases.
+
+Your strengths:
+- Rapidly finding files using glob patterns
+- Searching code and text with powerful regex patterns
+- Reading and analyzing file contents
+
+Guidelines:
+- Use glob for broad file pattern matching
+- Use grep for searching file contents with regex
+- Use read when you know the specific file path
+- Use bash ONLY for read-only operations (ls, find, cat, wc, head, tail)
+- Adapt your search approach based on the thoroughness level specified
+- Return file paths as absolute paths in your final response
+- Do NOT create, modify, or delete any files
+- Do NOT run commands that change system state
+
+Complete the search request efficiently and report findings clearly.
+
+Working directory: ${process.cwd()}
+Platform: ${process.platform}`;
+const EXPLORE_MAX_STEPS = 20;
+export function createExploreTool(modelId) {
+    return tool({
+        description: `Deep codebase exploration agent. Use this to understand project structure, find files by patterns, search code for keywords, trace module relationships, or answer questions about the codebase.
+
+Specify thoroughness:
+- "quick": basic search, 1-3 tool calls
+- "medium": moderate exploration, follow references
+- "thorough": comprehensive analysis across multiple locations and naming conventions
+
+Examples:
+- "Find all API route handlers" (medium)
+- "How does the auth system work?" (thorough)
+- "Where is the database config?" (quick)`,
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                query: { type: "string", description: "What to explore or find in the codebase" },
+                thoroughness: { type: "string", description: "Search depth: quick, medium, or thorough (default: medium)" },
+            },
+            required: ["query"],
+        }),
+        execute: async ({ query, thoroughness }) => {
+            const level = thoroughness ?? "medium";
+            console.log(`\x1b[90m  ┌─ Explore (${level}): ${query.slice(0, 60)}\x1b[0m`);
+            try {
+                const result = await runExploreAgent(query, level, modelId);
+                console.log(`\x1b[90m  └─ ✓ Done\x1b[0m`);
+                return truncateToolOutput(result, { direction: "head" }).content;
+            }
+            catch (err) {
+                console.log(`\x1b[90m  └─ ✗ Failed: ${err.message}\x1b[0m`);
+                return `Explore error: ${err.message}`;
+            }
+        },
+    });
+}
+async function runExploreAgent(query, thoroughness, modelId) {
+    const model = resolveModel(modelId);
+    // Read-only tools only
+    const tools = {
+        glob: globTool,
+        grep: grepTool,
+        read: readTool,
+        bash: bashTool, // bash is available but prompt restricts to read-only
+    };
+    const prompt = `Thoroughness level: ${thoroughness}
+${thoroughness === "quick" ? "Do a quick search (1-3 tool calls max)." : ""}
+${thoroughness === "medium" ? "Do a moderate exploration, follow references if needed." : ""}
+${thoroughness === "thorough" ? "Do a comprehensive analysis. Check multiple locations, naming conventions, and cross-references." : ""}
+
+Task: ${query}`;
+    const messages = [{ role: "user", content: prompt }];
+    const result = streamText({
+        model,
+        system: EXPLORE_SYSTEM,
+        messages,
+        tools,
+        stopWhen: stepCountIs(EXPLORE_MAX_STEPS),
+        maxRetries: 2,
+        onError() { },
+    });
+    let assistantText = "";
+    for await (const event of result.fullStream) {
+        switch (event.type) {
+            case "text-delta":
+                assistantText += event.text;
+                break;
+            case "tool-call":
+                console.log(`\x1b[90m  │ ⚡ ${event.toolName}\x1b[0m`);
+                break;
+        }
+    }
+    return stripThinkingFromAssistantText(assistantText) || "(explore agent produced no output)";
+}

package/dist/tools/index.js

@@ -6,8 +6,11 @@ import { globTool } from "./glob.js";
 import { grepTool } from "./grep.js";
 import { webSearchTool } from "./web_search.js";
 import { webFetchTool } from "./web_fetch.js";
+import { todoTool } from "./todo.js";
+import { questionTool } from "./question.js";
+import { codeSearchTool } from "./code_search.js";
 export function createTools() {
-    return {
+    const tools = {
         bash: bashTool,
         read: readTool,
         write: writeTool,
@@ -16,5 +19,11 @@ export function createTools() {
         grep: grepTool,
         web_search: webSearchTool,
         web_fetch: webFetchTool,
+        todo: todoTool,
+        question: questionTool,
     };
+    if (process.env.EXA_API_KEY) {
+        tools.codesearch = codeSearchTool;
+    }
+    return tools;
 }

package/dist/tools/question.js

@@ -0,0 +1,53 @@
+import { tool, jsonSchema } from "ai";
+import readline from "readline";
+export const questionTool = tool({
+    description: `Ask the user a question to get clarification before proceeding. Use this when:
+- The task is ambiguous and you need more information
+- There are multiple valid approaches and you want the user to choose
+- You need confirmation before a potentially destructive action
+- You're unsure about a requirement or preference
+
+Provide clear, specific questions. Optionally include numbered options for the user to choose from.`,
+    inputSchema: jsonSchema({
+        type: "object",
+        properties: {
+            question: { type: "string", description: "The question to ask the user" },
+            options: {
+                type: "array",
+                items: { type: "string" },
+                description: "Optional list of choices for the user to pick from",
+            },
+        },
+        required: ["question"],
+    }),
+    execute: async ({ question, options }) => {
+        console.log();
+        console.log(`\x1b[33m❓ ${question}\x1b[0m`);
+        if (options && options.length > 0) {
+            for (let i = 0; i < options.length; i++) {
+                console.log(`\x1b[90m   ${i + 1}. ${options[i]}\x1b[0m`);
+            }
+        }
+        const answer = await askUser();
+        // If user picked a number and options exist, resolve it
+        if (options && options.length > 0) {
+            const idx = parseInt(answer) - 1;
+            if (idx >= 0 && idx < options.length) {
+                return `User chose: ${options[idx]}`;
+            }
+        }
+        return `User answered: ${answer}`;
+    },
+});
+function askUser() {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question("\x1b[36m   → \x1b[0m", (answer) => {
+            rl.close();
+            resolve(answer.trim() || "(no answer)");
+        });
+    });
+}

package/dist/tools/read.js

@@ -2,6 +2,9 @@ import { tool, jsonSchema } from "ai";
 import { readFileSync, statSync } from "fs";
 import path from "path";
 import { truncateToolOutput } from "../tool-output.js";
+import { InstructionTracker } from "../instructions.js";
+// Shared tracker instance for context-aware instruction discovery
+const instructionTracker = new InstructionTracker();
 export const readTool = tool({
     description: "Read the contents of a file. Returns the file content as text. Use this to understand code, check configurations, etc.",
     inputSchema: jsonSchema({
@@ -20,14 +23,22 @@ export const readTool = tool({
             if (stat.isDirectory())
                 return `Error: ${filePath} is a directory, not a file`;
             const content = readFileSync(resolved, "utf-8");
+            let result;
             if (startLine || endLine) {
                 const lines = content.split("\n");
                 const start = (startLine ?? 1) - 1;
                 const end = endLine ?? lines.length;
-                const slice = lines.slice(start, end).join("\n");
-                return truncateToolOutput(slice, { direction: "head" }).content;
+                result = lines.slice(start, end).join("\n");
             }
-            return truncateToolOutput(content, { direction: "head" }).content;
+            else {
+                result = content;
+            }
+            // Context-aware: discover nearby instruction files
+            const nearbyInstructions = instructionTracker.resolveForFile(resolved);
+            if (nearbyInstructions.length > 0) {
+                result += "\n\n<system-reminder>\n" + nearbyInstructions.join("\n\n") + "\n</system-reminder>";
+            }
+            return truncateToolOutput(result, { direction: "head" }).content;
         }
         catch (err) {
             return `Error reading file: ${err.message}`;