min-agent 0.1.4 → 0.1.6

package/dist/compaction.js

@@ -1,29 +1,94 @@
 import { generateText } from "ai";
 /**
- * Context compaction system.
+ * Context compaction system — modeled after opencode's SessionCompaction.
  *
- * When conversation history exceeds a token threshold, older messages are
- * summarized into a compact form to free up context window space.
- *
- * Strategy:
- * 1. Estimate token count of messages (rough: 1 token ≈ 4 chars for English, 2 chars for CJK)
- * 2. When over threshold, take older messages and summarize them via the LLM
- * 3. Replace old messages with a single system summary message
- * 4. Keep recent N turns verbatim for continuity
+ * Features:
+ * 1. Real token tracking from API responses
+ * 2. Structured summary template (Goal/Progress/Decisions/Files)
+ * 3. Incremental summaries (update previous summary instead of rewriting)
+ * 4. Tool output pruning (trim old tool results to save space)
+ * 5. Auto-continue after compaction
+ * 6. Token-budget-aware tail preservation
  */
-const COMPACTION_PROMPT = `You are a conversation summarizer. Summarize the following conversation history into a concise but complete summary that preserves:
-- Key decisions made
-- Important context and facts discussed
-- Current state of any tasks in progress
-- User preferences mentioned
-- File paths, code snippets, or technical details that are still relevant
+// ─── Structured Summary Template (from opencode) ───────────────────────────
+const SUMMARY_TEMPLATE = `Output exactly the Markdown structure shown below. Keep the section order unchanged.
+
+## Goal
+- [single-sentence task summary]
+
+## Constraints & Preferences
+- [user constraints, preferences, specs, or "(none)"]
+
+## Progress
+### Done
+- [completed work or "(none)"]
+
+### In Progress
+- [current work or "(none)"]
+
+### Blocked
+- [blockers or "(none)"]
 
-Be concise but don't lose critical information. Output only the summary, no preamble.`;
-// Default: trigger compaction at ~80% of context window
+## Key Decisions
+- [decision and why, or "(none)"]
+
+## Next Steps
+- [ordered next actions or "(none)"]
+
+## Critical Context
+- [important technical facts, errors, open questions, or "(none)"]
+
+## Relevant Files
+- [file or directory path: why it matters, or "(none)"]
+
+Rules:
+- Keep every section, even when empty.
+- Use terse bullets, not prose paragraphs.
+- Preserve exact file paths, commands, error strings, and identifiers when known.
+- Do not mention the summary process or that context was compacted.`;
+// ─── Constants ─────────────────────────────────────────────────────────────
 const DEFAULT_MAX_TOKENS = 128000;
 const COMPACTION_RATIO = 0.75;
-const KEEP_RECENT_TURNS = 4; // Keep last N user+assistant pairs verbatim
-/** Rough token estimation */
+const DEFAULT_TAIL_TURNS = 2;
+const TAIL_TOKEN_BUDGET_RATIO = 0.25;
+const MIN_TAIL_BUDGET = 2000;
+const MAX_TAIL_BUDGET = 8000;
+const PRUNE_PROTECT_TOKENS = 40000;
+const PRUNE_MIN_SAVINGS = 20000;
+const TOOL_OUTPUT_MAX_CHARS = 2000;
+// ─── Token Tracker ─────────────────────────────────────────────────────────
+export class TokenTracker {
+    _lastInputTokens = 0;
+    _totalOutputTokens = 0;
+    _totalInputTokens = 0;
+    _totalCacheRead = 0;
+    update(usage) {
+        const input = usage.inputTokens ?? 0;
+        const output = usage.outputTokens ?? 0;
+        const cacheRead = usage.cachedInputTokens ?? 0;
+        this._lastInputTokens = input;
+        this._totalInputTokens += input;
+        this._totalOutputTokens += output;
+        this._totalCacheRead += cacheRead;
+    }
+    get lastInputTokens() {
+        return this._lastInputTokens;
+    }
+    get totalInputTokens() {
+        return this._totalInputTokens;
+    }
+    get totalOutputTokens() {
+        return this._totalOutputTokens;
+    }
+    summary() {
+        return `context: ${this._lastInputTokens} | total in: ${this._totalInputTokens} out: ${this._totalOutputTokens}`;
+    }
+    resetContext() {
+        this._lastInputTokens = 0;
+    }
+}
+// ─── Token Estimation ──────────────────────────────────────────────────────
+/** Rough token estimation (fallback) */
 export function estimateTokens(messages) {
     let chars = 0;
     for (const msg of messages) {
@@ -38,51 +103,180 @@ export function estimateTokens(messages) {
             }
         }
     }
-    // Rough estimate: mix of English (~4 chars/token) and CJK (~2 chars/token)
     return Math.ceil(chars / 3);
 }
-/** Check if compaction is needed */
-export function needsCompaction(messages, config) {
+function estimateMessageTokens(msg) {
+    if (typeof msg.content === "string")
+        return Math.ceil(msg.content.length / 3);
+    if (Array.isArray(msg.content)) {
+        let chars = 0;
+        for (const part of msg.content) {
+            if ("text" in part && typeof part.text === "string")
+                chars += part.text.length;
+        }
+        return Math.ceil(chars / 3);
+    }
+    return 0;
+}
+// ─── Compaction Check ──────────────────────────────────────────────────────
+export function needsCompaction(messages, tracker, config) {
     const maxTokens = config?.maxTokens ?? DEFAULT_MAX_TOKENS;
     const threshold = maxTokens * COMPACTION_RATIO;
+    if (tracker && tracker.lastInputTokens > 0) {
+        return tracker.lastInputTokens > threshold;
+    }
     return estimateTokens(messages) > threshold;
 }
-/** Compact messages by summarizing older history */
+// ─── Tool Output Pruning ───────────────────────────────────────────────────
+/**
+ * Prune old tool outputs in-place to free context space.
+ * Keeps recent tool outputs intact, trims older ones to a short summary.
+ * Returns the estimated tokens saved.
+ */
+export function pruneToolOutputs(messages) {
+    let totalTokens = 0;
+    let saved = 0;
+    let turns = 0;
+    // Walk backwards, skip recent 2 turns
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role === "user")
+            turns++;
+        if (turns < 2)
+            continue;
+        // Prune tool results in older messages
+        if (msg.role === "tool" || (Array.isArray(msg.content) && msg.content.some((p) => p.type === "tool-result"))) {
+            const content = typeof msg.content === "string" ? msg.content : "";
+            const estimate = Math.ceil(content.length / 3);
+            totalTokens += estimate;
+            if (totalTokens > PRUNE_PROTECT_TOKENS && content.length > TOOL_OUTPUT_MAX_CHARS) {
+                const truncated = content.slice(0, TOOL_OUTPUT_MAX_CHARS) + "\n\n[... output truncated during compaction ...]";
+                msg.content = truncated;
+                saved += estimate - Math.ceil(truncated.length / 3);
+            }
+        }
+    }
+    return saved;
+}
+/**
+ * Select how many recent turns to keep verbatim based on token budget.
+ * Similar to opencode's select() function.
+ */
+function selectTail(messages, config) {
+    const maxTokens = config?.maxTokens ?? DEFAULT_MAX_TOKENS;
+    const tailTurns = config?.keepRecentTurns ?? DEFAULT_TAIL_TURNS;
+    const budget = Math.min(MAX_TAIL_BUDGET, Math.max(MIN_TAIL_BUDGET, Math.floor(maxTokens * TAIL_TOKEN_BUDGET_RATIO)));
+    // Find user message boundaries (turns)
+    const turnStarts = [];
+    for (let i = 0; i < messages.length; i++) {
+        if (messages[i].role === "user")
+            turnStarts.push(i);
+    }
+    if (turnStarts.length <= 1) {
+        return { headEnd: 0, tailStart: 0 };
+    }
+    // Try to keep the last N turns within budget
+    let tokensUsed = 0;
+    let tailStart = messages.length;
+    const recentTurns = turnStarts.slice(-tailTurns);
+    for (let i = recentTurns.length - 1; i >= 0; i--) {
+        const turnStart = recentTurns[i];
+        const turnEnd = i < recentTurns.length - 1 ? recentTurns[i + 1] : messages.length;
+        let turnTokens = 0;
+        for (let j = turnStart; j < turnEnd; j++) {
+            turnTokens += estimateMessageTokens(messages[j]);
+        }
+        if (tokensUsed + turnTokens > budget && tokensUsed > 0)
+            break;
+        tokensUsed += turnTokens;
+        tailStart = turnStart;
+    }
+    if (tailStart >= messages.length)
+        tailStart = messages.length - 2;
+    if (tailStart < 0)
+        tailStart = 0;
+    return { headEnd: tailStart, tailStart };
+}
+// ─── Compaction Agent Prompt ────────────────────────────────────────────────
+const COMPACTION_AGENT_SYSTEM = `You are an anchored context summarization assistant for coding sessions.
+
+Summarize only the conversation history you are given. The newest turns may be kept verbatim outside your summary, so focus on the older context that still matters for continuing the work.
+
+If the prompt includes a <previous-summary> block, treat it as the current anchored summary. Update it with the new history by preserving still-true details, removing stale details, and merging in new facts.
+
+Always follow the exact output structure requested by the user prompt. Keep every section, preserve exact file paths and identifiers when known, and prefer terse bullets over paragraphs.
+
+Do not answer the conversation itself. Do not mention that you are summarizing, compacting, or merging context. Respond in the same language as the conversation.`;
+/** Previous summary stored in the first system message if present */
+function extractPreviousSummary(messages) {
+    const first = messages[0];
+    if (first?.role === "system" && typeof first.content === "string" && first.content.includes("[Context Summary")) {
+        // Extract just the summary content after the header
+        const match = first.content.match(/\[Context Summary[^\]]*\]\n\n([\s\S]*)/);
+        return match?.[1];
+    }
+    return undefined;
+}
+function buildCompactionPrompt(previousSummary) {
+    const anchor = previousSummary
+        ? [
+            "Update the anchored summary below using the conversation history above.",
+            "Preserve still-true details, remove stale details, and merge in the new facts.",
+            "",
+            "<previous-summary>",
+            previousSummary,
+            "</previous-summary>",
+        ].join("\n")
+        : "Create a new anchored summary from the conversation history above.";
+    return [anchor, "", SUMMARY_TEMPLATE].join("\n");
+}
+function messageToText(msg) {
+    if (typeof msg.content === "string")
+        return msg.content;
+    if (Array.isArray(msg.content)) {
+        return msg.content
+            .filter((p) => "text" in p && typeof p.text === "string")
+            .map((p) => p.text)
+            .join("\n");
+    }
+    return "";
+}
+/**
+ * Compact messages by summarizing older history with structured template.
+ * Supports incremental summaries and token-budget tail preservation.
+ */
 export async function compactMessages(messages, model, config) {
-    const keepTurns = config?.keepRecentTurns ?? KEEP_RECENT_TURNS;
-    if (messages.length <= keepTurns * 2) {
-        // Not enough messages to compact
-        return { messages, compacted: false };
-    }
-    // Split: older messages to summarize, recent messages to keep
-    const splitIdx = messages.length - keepTurns * 2;
-    const toSummarize = messages.slice(0, splitIdx);
-    const toKeep = messages.slice(splitIdx);
-    // Build conversation text for summarization
+    // Step 1: Prune old tool outputs first
+    pruneToolOutputs(messages);
+    // Step 2: Select tail (recent turns to keep verbatim)
+    const { headEnd, tailStart } = selectTail(messages, config);
+    if (headEnd <= 1) {
+        return { messages, compacted: false, shouldContinue: false };
+    }
+    const toSummarize = messages.slice(0, headEnd);
+    const toKeep = messages.slice(tailStart);
+    // Step 3: Check for previous summary (incremental)
+    const previousSummary = extractPreviousSummary(toSummarize);
+    // Step 4: Build conversation text for summarization
     const conversationText = toSummarize
         .map((msg) => {
         const role = msg.role;
-        const content = typeof msg.content === "string"
-            ? msg.content
-            : Array.isArray(msg.content)
-                ? msg.content
-                    .filter((p) => "text" in p)
-                    .map((p) => p.text)
-                    .join("\n")
-                : "";
-        return `[${role}]: ${content.slice(0, 2000)}`;
+        const text = messageToText(msg);
+        // Limit each message to avoid overwhelming the summarizer
+        return `[${role}]: ${text.slice(0, 3000)}`;
     })
         .join("\n\n");
+    // Step 5: Generate structured summary using dedicated compaction agent
     try {
+        const prompt = buildCompactionPrompt(previousSummary);
         const result = await generateText({
             model,
+            system: COMPACTION_AGENT_SYSTEM,
             messages: [
-                { role: "system", content: COMPACTION_PROMPT },
-                { role: "user", content: `Summarize this conversation:\n\n${conversationText}` },
+                { role: "user", content: conversationText + "\n\n" + prompt },
             ],
         });
         const summary = result.text;
-        // Build compacted message list
         const compactedMessages = [
             {
                 role: "system",
@@ -90,10 +284,11 @@ export async function compactMessages(messages, model, config) {
             },
             ...toKeep,
         ];
-        return { messages: compactedMessages, compacted: true };
+        const shouldContinue = config?.autoContinue !== false;
+        return { messages: compactedMessages, compacted: true, shouldContinue };
     }
     catch {
-        // If summarization fails, just truncate older messages
-        return { messages: toKeep, compacted: true };
+        // Fallback: just keep the tail
+        return { messages: toKeep, compacted: true, shouldContinue: false };
     }
 }

package/dist/config.js

@@ -56,20 +56,47 @@ function ask(rl, question, defaultValue) {
         });
     });
 }
+const MODELS_CACHE_FILE = path.join(CONFIG_DIR, "models-cache.json");
+function loadModelsCache() {
+    if (!existsSync(MODELS_CACHE_FILE))
+        return [];
+    try {
+        return JSON.parse(readFileSync(MODELS_CACHE_FILE, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+}
+function saveModelsCache(models) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(MODELS_CACHE_FILE, JSON.stringify(models), "utf-8");
+}
 export async function fetchModels(baseURL, apiKey) {
     try {
         const trimmed = baseURL.replace(/\/$/, "");
-        const primary = await fetchModelsFromURL(`${trimmed}/models`, apiKey);
-        if (primary.length > 0)
-            return primary;
+        let models = await fetchModelsFromURL(`${trimmed}/models`, apiKey);
         // Ollama users often provide host without /v1; auto-retry that variant.
-        if (!trimmed.endsWith("/v1")) {
-            return await fetchModelsFromURL(`${trimmed}/v1/models`, apiKey);
+        if (models.length === 0 && !trimmed.endsWith("/v1")) {
+            models = await fetchModelsFromURL(`${trimmed}/v1/models`, apiKey);
         }
-        return [];
+        if (models.length > 0) {
+            saveModelsCache(models);
+            return models;
+        }
+        // Fallback to cache if live fetch returned nothing
+        const cached = loadModelsCache();
+        if (cached.length > 0) {
+            console.log("\x1b[90m  (using cached model list)\x1b[0m");
+        }
+        return cached;
     }
     catch {
-        return [];
+        // Network error — fallback to cache
+        const cached = loadModelsCache();
+        if (cached.length > 0) {
+            console.log("\x1b[90m  (using cached model list — network unavailable)\x1b[0m");
+        }
+        return cached;
     }
 }
 export async function runSetup() {

package/dist/context-window.js

@@ -0,0 +1,185 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import path from "path";
+import { getConfigDir, loadConfig } from "./config.js";
+/**
+ * Auto-detect context window size for the current model.
+ *
+ * Resolution order:
+ * 1. User config: provider.contextWindow (explicit override)
+ * 2. Provider-specific API (OpenRouter, vLLM, Ollama)
+ * 3. models.dev API lookup
+ * 4. Fallback: 128000
+ */
+const DEFAULT_CONTEXT_WINDOW = 128000;
+const CACHE_FILE = path.join(getConfigDir(), "context-window-cache.json");
+const CACHE_TTL = 7 * 24 * 60 * 60 * 1000; // 7 days
+function loadCache() {
+    if (!existsSync(CACHE_FILE))
+        return {};
+    try {
+        return JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function saveCache(cache) {
+    mkdirSync(path.dirname(CACHE_FILE), { recursive: true });
+    writeFileSync(CACHE_FILE, JSON.stringify(cache), "utf-8");
+}
+function getCached(modelId) {
+    const cache = loadCache();
+    const entry = cache[modelId];
+    if (!entry)
+        return null;
+    if (Date.now() - entry.timestamp > CACHE_TTL)
+        return null;
+    return entry.contextWindow;
+}
+function setCache(modelId, contextWindow) {
+    const cache = loadCache();
+    cache[modelId] = { contextWindow, timestamp: Date.now() };
+    saveCache(cache);
+}
+/** Try OpenRouter: GET /api/v1/models returns context_length per model */
+async function tryOpenRouter(baseURL, apiKey, modelId) {
+    if (!baseURL.includes("openrouter"))
+        return null;
+    try {
+        const response = await fetch("https://openrouter.ai/api/v1/models", {
+            headers: { Authorization: `Bearer ${apiKey}` },
+            signal: AbortSignal.timeout(8000),
+        });
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        const model = data.data?.find((m) => m.id === modelId);
+        return model?.context_length ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Try vLLM: GET /v1/models returns max_model_len */
+async function tryVllm(baseURL, apiKey, modelId) {
+    try {
+        const url = `${baseURL.replace(/\/$/, "")}/models`;
+        const response = await fetch(url, {
+            headers: { Authorization: `Bearer ${apiKey}` },
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        const model = (data.data ?? []).find((m) => m.id === modelId);
+        // vLLM exposes max_model_len on the model object
+        return model?.max_model_len ?? model?.max_model_length ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Try Ollama: POST /api/show returns model info with context length */
+async function tryOllama(baseURL, modelId) {
+    if (!baseURL.includes("localhost") && !baseURL.includes("127.0.0.1") && !baseURL.includes("ollama"))
+        return null;
+    try {
+        // Ollama's /api/show endpoint
+        const ollamaBase = baseURL.replace(/\/v1\/?$/, "");
+        const response = await fetch(`${ollamaBase}/api/show`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name: modelId }),
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        // Ollama returns model_info with context length
+        const ctxLength = data.model_info?.["general.context_length"] ??
+            data.model_info?.context_length ??
+            data.parameters?.num_ctx;
+        return typeof ctxLength === "number" ? ctxLength : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Try models.dev API */
+async function tryModelsDev(modelId) {
+    try {
+        const response = await fetch("https://models.dev/api.json", {
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!response.ok)
+            return null;
+        const providers = (await response.json());
+        // Search all providers for the model ID
+        for (const provider of Object.values(providers)) {
+            if (!provider.models)
+                continue;
+            const model = provider.models[modelId];
+            if (model?.limit?.context)
+                return model.limit.context;
+        }
+        // Try partial match (some providers prefix model IDs)
+        for (const provider of Object.values(providers)) {
+            if (!provider.models)
+                continue;
+            for (const [id, model] of Object.entries(provider.models)) {
+                if (id === modelId || id.endsWith(`/${modelId}`) || modelId.endsWith(`/${id}`)) {
+                    if (model?.limit?.context)
+                        return model.limit.context;
+                }
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get context window size for the current model.
+ * Tries multiple sources, caches the result.
+ */
+export async function getContextWindow(modelId) {
+    const config = loadConfig();
+    // 1. Explicit user config
+    if (config.provider?.contextWindow)
+        return config.provider.contextWindow;
+    const id = modelId ?? config.provider?.defaultModel;
+    if (!id)
+        return DEFAULT_CONTEXT_WINDOW;
+    // 2. Check cache
+    const cached = getCached(id);
+    if (cached !== null)
+        return cached;
+    const baseURL = config.provider?.baseURL ?? "";
+    const apiKey = config.provider?.apiKey ?? "";
+    // 3. Provider-specific APIs
+    const openRouter = await tryOpenRouter(baseURL, apiKey, id);
+    if (openRouter) {
+        setCache(id, openRouter);
+        return openRouter;
+    }
+    const ollama = await tryOllama(baseURL, id);
+    if (ollama) {
+        setCache(id, ollama);
+        return ollama;
+    }
+    const vllm = await tryVllm(baseURL, apiKey, id);
+    if (vllm) {
+        setCache(id, vllm);
+        return vllm;
+    }
+    // 4. models.dev lookup
+    const modelsDev = await tryModelsDev(id);
+    if (modelsDev) {
+        setCache(id, modelsDev);
+        return modelsDev;
+    }
+    // 5. Fallback
+    setCache(id, DEFAULT_CONTEXT_WINDOW);
+    return DEFAULT_CONTEXT_WINDOW;
+}

package/dist/doom-loop.js

@@ -0,0 +1,36 @@
+/**
+ * Doom loop detection.
+ *
+ * Detects when the agent calls the same tool with the same arguments
+ * repeatedly (indicating it's stuck in a loop). After THRESHOLD consecutive
+ * identical calls, the loop is broken and the agent is informed.
+ *
+ * Based on opencode's processor.ts doom loop detection.
+ */
+const THRESHOLD = 3;
+export class DoomLoopDetector {
+    recentCalls = [];
+    /** Record a tool call. Returns true if a doom loop is detected. */
+    record(toolName, input) {
+        const serialized = JSON.stringify(input);
+        this.recentCalls.push({ toolName, input: serialized });
+        // Only check the last THRESHOLD calls
+        if (this.recentCalls.length < THRESHOLD)
+            return false;
+        const recent = this.recentCalls.slice(-THRESHOLD);
+        const allSame = recent.every((call) => call.toolName === recent[0].toolName && call.input === recent[0].input);
+        if (allSame) {
+            // Reset to prevent repeated warnings
+            this.recentCalls = [];
+            return true;
+        }
+        // Keep only last THRESHOLD entries to bound memory
+        if (this.recentCalls.length > THRESHOLD * 2) {
+            this.recentCalls = this.recentCalls.slice(-THRESHOLD);
+        }
+        return false;
+    }
+    reset() {
+        this.recentCalls = [];
+    }
+}

package/dist/instructions.js

@@ -11,8 +11,50 @@ import { getRulesFile, loadConfig } from "./config.js";
  *
  * Project-level rules (auto-discovered from cwd):
  *   ./AGENTS.md, ./RULES.md, ./.min-agent/AGENTS.md
+ *
+ * Context-aware (like opencode):
+ *   When the agent reads a file, nearby AGENTS.md/RULES.md are auto-loaded.
  */
 const PROJECT_FILES = ["AGENTS.md", "RULES.md", "CLAUDE.md"];
+/** Tracks which instruction files have already been loaded to avoid duplicates */
+export class InstructionTracker {
+    loaded = new Set();
+    isLoaded(filepath) {
+        return this.loaded.has(path.resolve(filepath));
+    }
+    markLoaded(filepath) {
+        this.loaded.add(path.resolve(filepath));
+    }
+    /**
+     * Context-aware: when a file is read, walk up from its directory
+     * looking for AGENTS.md/RULES.md that haven't been loaded yet.
+     * Returns new instruction content to inject.
+     */
+    resolveForFile(filepath) {
+        const results = [];
+        const root = process.cwd();
+        let current = path.dirname(path.resolve(filepath));
+        while (current.startsWith(root) && current !== path.dirname(root)) {
+            for (const file of PROJECT_FILES) {
+                const candidate = path.join(current, file);
+                if (existsSync(candidate) && !this.isLoaded(candidate)) {
+                    try {
+                        const content = readFileSync(candidate, "utf-8").trim();
+                        if (content) {
+                            this.markLoaded(candidate);
+                            results.push(`Instructions from: ${candidate}\n${content}`);
+                        }
+                    }
+                    catch { }
+                }
+            }
+            if (results.length > 0)
+                break;
+            current = path.dirname(current);
+        }
+        return results;
+    }
+}
 function findProjectInstructions() {
     const results = [];
     let current = process.cwd();