@datename/fastcode-termux 0.0.0-stage → 0.1.6-beta

package/dist/agent/compaction.js

@@ -0,0 +1,227 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { estMessagesTokens, estTokens } from "../lib/model-meta.js";
+import { getPaths } from "../config/paths.js";
+import { parseToolCalls, stripToolCalls } from "./protocol.js";
+export const DEFAULT_COMPACTION_CONFIG = {
+    enabled: true,
+    localThresholdRatio: 0.7,
+    keepTurns: 6,
+    serverCompactionAware: false,
+    clampAboveServerByTokens: 8192,
+    maxSummaryTokens: 1500,
+    heapLimitMb: 220,
+};
+export function compactionConfigFromEnv() {
+    const config = { ...DEFAULT_COMPACTION_CONFIG };
+    const disabled = (process.env["FASTCODE_COMPACTION"] ?? "").trim().toLowerCase();
+    if (["0", "false", "no", "off"].includes(disabled))
+        config.enabled = false;
+    const heap = Number(process.env["FASTCODE_HEAP_LIMIT_MB"]);
+    if (Number.isFinite(heap) && heap > 0)
+        config.heapLimitMb = heap;
+    const server = (process.env["FASTCODE_SERVER_COMPACTION"] ?? "").trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(server))
+        config.serverCompactionAware = true;
+    return config;
+}
+export function localThresholdTokens(config, contextWindow) {
+    const local = Math.floor(Math.max(1, contextWindow) * config.localThresholdRatio);
+    if (config.serverCompactionAware && typeof config.serverCompactThreshold === "number" && config.serverCompactThreshold > 0) {
+        return Math.max(local, config.serverCompactThreshold + config.clampAboveServerByTokens);
+    }
+    return local;
+}
+export function heapExceeded(config) {
+    const used = process.memoryUsage().heapUsed;
+    return used > Math.max(0, config.heapLimitMb) * 1024 * 1024;
+}
+export function shouldCompact(messages, config, options) {
+    if (!config.enabled)
+        return false;
+    if (options.force || heapExceeded(config))
+        return true;
+    return messageTokens(messages, options) > localThresholdTokens(config, options.contextWindow);
+}
+export function compactMessages(messages, config = DEFAULT_COMPACTION_CONFIG, options) {
+    const beforeTokens = messageTokens(messages, options);
+    const beforeChars = messageChars(messages);
+    const heap = heapExceeded(config);
+    const noop = {
+        messages,
+        compacted: false,
+        source: "none",
+        beforeTokens,
+        afterTokens: beforeTokens,
+        beforeChars,
+        afterChars: beforeChars,
+        droppedMessages: 0,
+        keptMessages: messages.length,
+    };
+    if (!config.enabled)
+        return noop;
+    const threshold = localThresholdTokens(config, options.contextWindow);
+    if (!options.force && !heap && beforeTokens <= threshold)
+        return noop;
+    const reason = heap && beforeTokens <= threshold ? "heap" : "threshold";
+    if (config.serverCompactionAware && options.serverOpaqueState) {
+        return {
+            ...noop,
+            compacted: true,
+            reason,
+            source: "server",
+        };
+    }
+    const headCount = messages[0]?.role === "user" ? 1 : 0;
+    const keep = Math.max(2, Math.floor(config.keepTurns * 2));
+    const tailStart = Math.max(headCount, messages.length - keep);
+    if (tailStart <= headCount)
+        return noop;
+    const middle = messages.slice(headCount, tailStart);
+    const summary = buildSummary(middle, config, options);
+    const summaryFile = writeSummaryFile(summary);
+    const marker = {
+        role: "system",
+        content: `[context compacted: ${middle.length} earlier messages were summarized to stay within the context window.` +
+            `${summaryFile ? ` Summary file: ${summaryFile}.` : ""} Recent turns are kept verbatim.` +
+            " If an earlier detail is missing, re-read that file with a tool.]\n\n" +
+            summary,
+    };
+    const next = [...messages.slice(0, headCount), marker, ...messages.slice(tailStart)];
+    return {
+        messages: next,
+        compacted: true,
+        reason,
+        source: "local",
+        beforeTokens,
+        afterTokens: messageTokens(next, options),
+        beforeChars,
+        afterChars: messageChars(next),
+        droppedMessages: middle.length,
+        keptMessages: next.length - headCount - 1,
+        summary,
+        summaryFile,
+    };
+}
+function messageTokens(messages, options) {
+    return estMessagesTokens(messages, { providerId: options.providerId, model: options.model });
+}
+function messageChars(messages) {
+    return messages.reduce((sum, message) => sum + (message.content?.length ?? 0), 0);
+}
+export function buildSummary(messages, config, options) {
+    const requests = [];
+    const actions = [];
+    const outcomes = [];
+    const notes = [];
+    const files = new Set();
+    for (const message of messages) {
+        if (!message.content)
+            continue;
+        if (message.role === "user") {
+            if (message.content.startsWith("FastCode executed the requested local tools.")) {
+                for (const line of message.content.split(/\r?\n/)) {
+                    if (/error|failed|not found|denied|timed out/i.test(line))
+                        outcomes.push(clip(line, 240));
+                }
+            }
+            else {
+                requests.push(clip(message.content, 300));
+            }
+            collectFiles(message.content, files);
+            continue;
+        }
+        if (message.role === "assistant") {
+            const calls = parseToolCalls(message.content);
+            for (const call of calls)
+                actions.push(describeCall(call));
+            const visible = stripToolCalls(message.content);
+            if (visible)
+                notes.push(clip(visible, 300));
+            collectFiles(message.content, files);
+            continue;
+        }
+        const lines = message.content.split(/\r?\n/);
+        for (const line of lines) {
+            if (/error|failed|not found|denied|timed out/i.test(line))
+                outcomes.push(clip(line, 240));
+        }
+        collectFiles(message.content, files);
+    }
+    const sections = [
+        "# Session summary",
+        "",
+        "## Requests",
+        ...limitLines(requests, 8).map((line) => `- ${line}`),
+        "",
+        "## Actions",
+        ...limitLines(actions, 20).map((line) => `- ${line}`),
+        "",
+        "## Outcomes",
+        ...limitLines(outcomes, 10).map((line) => `- ${line}`),
+        "",
+        "## Files touched",
+        ...(files.size > 0 ? Array.from(files).slice(0, 40).map((file) => `- ${file}`) : ["- (none recorded)"]),
+        "",
+        "## Notes",
+        ...limitLines(notes, 10).map((line) => `- ${line}`),
+    ];
+    const budget = Math.max(200, Math.floor(config.maxSummaryTokens));
+    const kept = [];
+    let used = 0;
+    for (const line of sections) {
+        const cost = estTokens(line + "\n", options);
+        if (used + cost > budget) {
+            kept.push("[... summary truncated ...]");
+            break;
+        }
+        kept.push(line);
+        used += cost;
+    }
+    return kept.join("\n").trimEnd() + "\n";
+}
+function describeCall(call) {
+    const tool = String(call?.tool ?? "unknown");
+    if (tool === "shell" && typeof call.command === "string")
+        return `shell: ${clip(call.command, 200)}`;
+    if (typeof call.path === "string")
+        return `${tool}: ${call.path}`;
+    if (typeof call.from === "string" || typeof call.to === "string")
+        return `${tool}: ${call.from ?? "?"} -> ${call.to ?? "?"}`;
+    if (typeof call.pattern === "string")
+        return `${tool}: /${clip(call.pattern, 120)}/`;
+    return tool;
+}
+function collectFiles(text, files) {
+    const matches = text.match(/[A-Za-z0-9_@./\\-]+\.[A-Za-z0-9]{1,8}\b/g);
+    if (!matches)
+        return;
+    for (const match of matches) {
+        if (match.length <= 3 || match.length > 240)
+            continue;
+        if (/^\d+(\.\d+)+$/.test(match))
+            continue;
+        files.add(match);
+        if (files.size >= 200)
+            return;
+    }
+}
+function limitLines(lines, max) {
+    return lines.slice(0, max);
+}
+function clip(text, max) {
+    const oneLine = String(text).replace(/\s+/g, " ").trim();
+    return oneLine.length > max ? oneLine.slice(0, max) + "…" : oneLine;
+}
+function writeSummaryFile(summary) {
+    try {
+        const dir = getPaths().sessions;
+        mkdirSync(dir, { recursive: true });
+        const file = join(dir, `summary-${Date.now()}-${Math.random().toString(36).slice(2, 6)}.md`);
+        writeFileSync(file, summary, "utf8");
+        return file;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/agent/context.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Context compaction for long agent sessions.
+ *
+ * The chat loop keeps appending tool results to the conversation, so a long
+ * investigation can grow past the model's window and fail with a provider 400.
+ * Instead of silently truncating the tail (which loses the current task), we
+ * keep the first user request and the most recent turns, and shrink the middle
+ * into short summaries with an explicit marker.
+ *
+ * Token counts are approximated at 4 characters per token. That is deliberately
+ * crude: it must work for every provider without a tokenizer dependency.
+ */
+import type { ChatMessage } from "../types.js";
+export interface CompactOptions {
+    /** Character budget for the whole history (default 400k ≈ 100k tokens). */
+    maxChars?: number;
+    /** Number of trailing messages to keep verbatim. */
+    keepRecent?: number;
+    /** Maximum characters kept from one old tool result. */
+    toolSummaryChars?: number;
+}
+export interface CompactResult {
+    messages: ChatMessage[];
+    compacted: boolean;
+    beforeChars: number;
+    afterChars: number;
+}
+export declare function historyChars(messages: ChatMessage[]): number;
+export declare function compactHistory(messages: ChatMessage[], options?: CompactOptions): CompactResult;

package/dist/agent/context.js

@@ -0,0 +1,62 @@
+const TOOL_MARKER = "FastCode executed the requested local tools.";
+export function historyChars(messages) {
+    return messages.reduce((sum, message) => sum + (message.content?.length ?? 0), 0);
+}
+export function compactHistory(messages, options = {}) {
+    const beforeChars = historyChars(messages);
+    const maxChars = positive(options.maxChars, 400_000);
+    const keepRecent = Math.max(2, Math.floor(positive(options.keepRecent, 6)));
+    const toolSummaryChars = Math.max(200, Math.floor(positive(options.toolSummaryChars, 2_000)));
+    if (beforeChars <= maxChars || messages.length <= keepRecent + 1) {
+        return { messages, compacted: false, beforeChars, afterChars: beforeChars };
+    }
+    // Keep the original request (usually the first message) plus the newest
+    // turns. Everything between is summarized, never dropped without a marker.
+    const head = messages[0]?.role === "user" ? [messages[0]] : [];
+    const tailStart = Math.max(head.length, messages.length - keepRecent);
+    const middle = messages.slice(head.length, tailStart);
+    const summarized = middle.map((message) => ({
+        role: message.role,
+        content: summarizeMessage(message.content, toolSummaryChars),
+    }));
+    const marker = {
+        role: "system",
+        content: `[context compacted: ${middle.length} earlier message(s) were summarized to stay within the context window. ` +
+            `Recent tool results are kept in full. If an earlier detail is missing, re-read that file with a tool.]`,
+    };
+    const next = [...head, marker, ...summarized, ...messages.slice(tailStart)];
+    return {
+        messages: next,
+        compacted: true,
+        beforeChars,
+        afterChars: historyChars(next),
+    };
+}
+function summarizeMessage(content, limit) {
+    if (!content)
+        return content;
+    if (content.includes(TOOL_MARKER))
+        return summarizeToolMessage(content, limit);
+    if (content.length <= limit)
+        return content;
+    const head = content.slice(0, Math.floor(limit * 0.6));
+    const tail = content.slice(-Math.floor(limit * 0.3));
+    return `${head}\n[… ${content.length - head.length - tail.length} chars summarized …]\n${tail}`;
+}
+/**
+ * Tool results have the shape:
+ *   FastCode executed ...\n\nTool result 1 (ok)\ncall: {...}\noutput:\n```...```
+ * Keep the call and the start/end of each output so file paths and errors
+ * survive compaction.
+ */
+function summarizeToolMessage(content, limit) {
+    if (content.length <= limit)
+        return content;
+    const keep = Math.max(120, Math.floor((limit - 240) / 2));
+    const head = content.slice(0, keep);
+    const tail = content.slice(-keep);
+    return `${head}\n[… ${content.length - keep * 2} chars of tool output summarized; re-run the tool if you need the middle …]\n${tail}`;
+}
+function positive(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}

package/dist/agent/guards.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Dangerous-command guard.
+ *
+ * Blocks destructive shell patterns before execution. Word-boundary escapes
+ * are written as character classes so the intent is identical without
+ * boundary syntax.
+ *
+ * Overrides:
+ *   FASTCODE_ALLOW_DANGEROUS=1        bypass the deny list (reported in output)
+ *   FASTCODE_SHELL_ALLOWLIST=a;b      only commands matching these regexes run
+ *   FASTCODE_SHELL_DENY_EXTRA=x;y     extra regexes to deny
+ *   FASTCODE_RESTRICT_TO_WORKSPACE=1  also reject ../ and .. escapes
+ */
+export declare const DEFAULT_DENY_PATTERNS: string[];
+export declare const FORK_BOMB_MARKERS: string[];
+/**
+ * Decide whether a shell command may run.
+ * Returns { allow: true } or { allow: false, output: explanation }.
+ */
+export declare function evaluateShellCommand(command: any): {
+    allow: boolean;
+    output: any;
+    bypassed: boolean;
+    pattern?: undefined;
+} | {
+    allow: boolean;
+    pattern: string;
+    output: string;
+    bypassed?: undefined;
+} | {
+    allow: boolean;
+    output: string;
+    bypassed?: undefined;
+    pattern?: undefined;
+};
+export declare const READ_ONLY_TOOLS: Set<string>;
+export declare function splitCommandSegments(command: any): any[];
+export declare function isReadOnlyCommand(command: any): boolean;
+export declare function isReadOnlyToolCall(call: any): boolean;
+export declare function loopExemptTools(): Set<string>;
+export declare function isLoopExempt(tool: any): boolean;
+export declare function stableStringify(value: any): any;
+export declare function toolCallFingerprint(call: any, cwd?: string): string;

package/dist/agent/guards.js

@@ -0,0 +1,269 @@
+import { normalize, resolve } from "node:path";
+/**
+ * Dangerous-command guard.
+ *
+ * Blocks destructive shell patterns before execution. Word-boundary escapes
+ * are written as character classes so the intent is identical without
+ * boundary syntax.
+ *
+ * Overrides:
+ *   FASTCODE_ALLOW_DANGEROUS=1        bypass the deny list (reported in output)
+ *   FASTCODE_SHELL_ALLOWLIST=a;b      only commands matching these regexes run
+ *   FASTCODE_SHELL_DENY_EXTRA=x;y     extra regexes to deny
+ *   FASTCODE_RESTRICT_TO_WORKSPACE=1  also reject ../ and .. escapes
+ */
+export const DEFAULT_DENY_PATTERNS = [
+    "(^|[^a-z])rm +-[rf]{1,2}([^a-z]|$)",
+    "(^|[^a-z])del +/[fq]([^a-z]|$)",
+    "(^|[^a-z])rmdir +/s([^a-z]|$)",
+    "(^|[^a-z-])(format|mkfs|diskpart)([^a-z]|$)",
+    "(^|[^a-z])dd +if=",
+    "> */dev/sd",
+    "(^|[^a-z])(shutdown|reboot|poweroff)([^a-z]|$)",
+];
+export const FORK_BOMB_MARKERS = [":(){", ":|:&"];
+function enabled(name) {
+    const value = process.env[name];
+    if (value === undefined)
+        return false;
+    return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+}
+function splitList(value) {
+    return (value ?? "").split(/[;,]/).map((entry) => entry.trim()).filter(Boolean);
+}
+function matches(lower, pattern) {
+    try {
+        return new RegExp(pattern).test(lower);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Decide whether a shell command may run.
+ * Returns { allow: true } or { allow: false, output: explanation }.
+ */
+export function evaluateShellCommand(command) {
+    const cmd = String(command ?? "").trim();
+    const lower = cmd.toLowerCase();
+    if (enabled("FASTCODE_ALLOW_DANGEROUS"))
+        return { allow: true, output: undefined, bypassed: true };
+    const deny = DEFAULT_DENY_PATTERNS.concat(splitList(process.env["FASTCODE_SHELL_DENY_EXTRA"]));
+    for (const pattern of deny) {
+        if (matches(lower, pattern)) {
+            return {
+                allow: false,
+                pattern,
+                output: "Error: blocked by the safety guard (dangerous pattern: " + pattern + "). " +
+                    "Set FASTCODE_ALLOW_DANGEROUS=1 to override.",
+            };
+        }
+    }
+    for (const marker of FORK_BOMB_MARKERS) {
+        if (lower.includes(marker))
+            return { allow: false, output: "Error: blocked by the safety guard (fork bomb pattern)." };
+    }
+    const allowlist = splitList(process.env["FASTCODE_SHELL_ALLOWLIST"]);
+    if (allowlist.length > 0 && !allowlist.some((pattern) => matches(lower, pattern)))
+        return { allow: false, output: "Error: blocked by the safety guard (not in FASTCODE_SHELL_ALLOWLIST)." };
+    if (enabled("FASTCODE_RESTRICT_TO_WORKSPACE")) {
+        const backslash = String.fromCharCode(92);
+        if (cmd.includes("../") || cmd.includes(".." + backslash))
+            return { allow: false, output: "Error: blocked by the safety guard (path traversal)." };
+    }
+    return { allow: true, output: undefined };
+}
+export const READ_ONLY_TOOLS = new Set([
+    "pwd", "read_file", "read_many", "list_files", "grep", "stat_path",
+]);
+const READ_ONLY_COMMANDS = new Set([
+    "pwd", "ls", "dir", "cat", "head", "tail", "wc", "stat", "file", "du", "df",
+    "grep", "rg", "egrep", "fgrep", "which", "whereis", "where", "whoami", "id",
+    "groups", "uname", "date", "uptime", "printenv", "echo", "printf",
+    "true", "false", "basename", "dirname", "realpath", "readlink", "tree",
+    "more", "less", "jq", "cut", "tr",
+]);
+const READ_ONLY_PREFIXES = new Set([
+    "git status", "git diff", "git log", "git show", "git rev-parse",
+    "git ls-files", "git blame", "git grep", "git describe", "git merge-base",
+    "git cat-file", "git rev-list", "git shortlog", "git whatchanged",
+    "npm ls", "npm list", "npm view", "npm outdated", "npm explain", "npm why",
+    "pnpm list", "pnpm ls", "yarn list", "yarn info",
+    "cargo tree", "go list", "pip list", "pip show",
+    "docker ps", "docker images", "docker logs",
+]);
+const NON_READ_ONLY_LEADERS = new Set([
+    "cd", "sudo", "doas", "env", "xargs", "time", "command", "eval", "exec",
+    "source", ".", "sh", "bash", "zsh", "fish", "powershell", "cmd",
+]);
+function scanCommand(command, onChar) {
+    let quote = "";
+    let escaped = false;
+    for (let i = 0; i < command.length; i += 1) {
+        const char = command[i];
+        if (escaped) {
+            escaped = false;
+            onChar(char, i, quote);
+            continue;
+        }
+        if (char === "\\") {
+            escaped = true;
+            onChar(char, i, quote);
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = "";
+            onChar(char, i, quote);
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            onChar(char, i, quote);
+            continue;
+        }
+        onChar(char, i, quote);
+    }
+    return quote === "";
+}
+function hasWriteRedirection(command) {
+    let found = false;
+    const balanced = scanCommand(command, (char, index, quote) => {
+        if (quote || char !== ">")
+            return;
+        const previous = command[index - 1];
+        if (previous === "=")
+            return;
+        found = true;
+    });
+    return !balanced || found;
+}
+function hasCommandSubstitution(command) {
+    let found = false;
+    const balanced = scanCommand(command, (char, index, quote) => {
+        if (quote)
+            return;
+        if (char === "`" || (char === "$" && command[index + 1] === "("))
+            found = true;
+    });
+    return !balanced || found;
+}
+export function splitCommandSegments(command) {
+    const parts = [];
+    let current = "";
+    let quote = "";
+    let escaped = false;
+    for (let i = 0; i < command.length; i += 1) {
+        const char = command[i];
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            current += char;
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            current += char;
+            if (char === quote)
+                quote = "";
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            current += char;
+            continue;
+        }
+        const next = command[i + 1];
+        if ((char === "&" && next === "&") || (char === "|" && next === "|")) {
+            parts.push(current);
+            current = "";
+            i += 1;
+            continue;
+        }
+        if (char === ";" || char === "|" || char === "&" || char === "\n") {
+            parts.push(current);
+            current = "";
+            continue;
+        }
+        current += char;
+    }
+    parts.push(current);
+    return parts.map((part) => part.trim()).filter(Boolean);
+}
+function isReadOnlySegment(segment) {
+    const tokens = segment.split(/\s+/).filter(Boolean);
+    if (tokens.length === 0)
+        return true;
+    const first = tokens[0].toLowerCase();
+    const second = (tokens[1] ?? "").toLowerCase();
+    if (NON_READ_ONLY_LEADERS.has(first))
+        return false;
+    if (READ_ONLY_PREFIXES.has(first + " " + second))
+        return true;
+    if (READ_ONLY_COMMANDS.has(first))
+        return true;
+    return false;
+}
+export function isReadOnlyCommand(command) {
+    const cmd = String(command ?? "").trim();
+    if (!cmd)
+        return false;
+    if (hasWriteRedirection(cmd) || hasCommandSubstitution(cmd))
+        return false;
+    const segments = splitCommandSegments(cmd);
+    if (segments.length === 0)
+        return false;
+    return segments.every(isReadOnlySegment);
+}
+export function isReadOnlyToolCall(call) {
+    const tool = typeof call?.tool === "string" ? call.tool : "";
+    if (tool === "shell")
+        return isReadOnlyCommand(call.command);
+    return READ_ONLY_TOOLS.has(tool);
+}
+export function loopExemptTools() {
+    const raw = process.env["FASTCODE_LOOP_EXEMPT"] ?? "";
+    return new Set(raw.split(",").map((entry) => entry.trim()).filter(Boolean));
+}
+export function isLoopExempt(tool) {
+    return loopExemptTools().has(String(tool ?? ""));
+}
+function stableValue(value) {
+    if (value === undefined)
+        return "null";
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return "[" + value.map((entry) => stableValue(entry)).join(",") + "]";
+    const keys = Object.keys(value).sort().filter((key) => value[key] !== undefined);
+    return "{" + keys.map((key) => JSON.stringify(key) + ":" + stableValue(value[key])).join(",") + "}";
+}
+export function stableStringify(value) {
+    return stableValue(value);
+}
+function normalizeFingerprintPath(value, cwd) {
+    let normalized = normalize(resolve(cwd, value));
+    if (normalized.length > 1)
+        normalized = normalized.replace(/[\\/]+$/, "");
+    return normalized;
+}
+function fingerprintValue(key, value, cwd) {
+    if (typeof value === "string" && (key === "path" || key === "from" || key === "to" || key === "cwd"))
+        return normalizeFingerprintPath(value, cwd);
+    if (key === "paths" && Array.isArray(value))
+        return value.map((entry) => typeof entry === "string" ? normalizeFingerprintPath(entry, cwd) : entry);
+    return value;
+}
+export function toolCallFingerprint(call, cwd = process.cwd()) {
+    const tool = typeof call?.tool === "string" ? call.tool : "unknown";
+    const args = {};
+    for (const key of Object.keys(call ?? {}).sort()) {
+        if (key === "tool" || key === "timeoutMs")
+            continue;
+        args[key] = fingerprintValue(key, call[key], cwd);
+    }
+    return tool + ":" + stableStringify(args);
+}

package/dist/agent/ignore.d.ts

@@ -0,0 +1,11 @@
+export interface IgnoreRule {
+    regex: RegExp;
+    negate: boolean;
+    dirOnly: boolean;
+}
+export interface IgnoreMatcher {
+    ignored(name: string, fullPath: string, isDir: boolean): boolean;
+    isBinary(name: string): boolean;
+}
+export declare function isBinaryName(name: string): boolean;
+export declare function createIgnore(root: string): IgnoreMatcher;