@datename/fastcode-termux 0.1.6-beta → 0.1.6

package/src/agent/approval.ts

@@ -1,47 +0,0 @@
-export type ApprovalScope = "once" | "session" | "always";
-
-export type ApprovalReason =
-  | "trust"
-  | "sensitive_path"
-  | "ambiguous_match"
-  | "destructive"
-  | "large_diff";
-
-export interface ChoiceItem {
-  label: string;
-  value: string;
-}
-
-export type ApprovalPreview =
-  | { kind: "diff"; text: string }
-  | { kind: "choices"; items: ChoiceItem[] };
-
-export type ApprovalOption =
-  | { kind: "allow"; scope: ApprovalScope; label: string }
-  | { kind: "deny"; label: string }
-  | { kind: "choose"; label: string; value: string }
-  | { kind: "feedback"; label: string; prompt: string };
-
-export interface ApprovalRequest {
-  id: string;
-  tool: string;
-  args: unknown;
-  reason: ApprovalReason;
-  options: ApprovalOption[];
-  preview?: ApprovalPreview;
-}
-
-export type ApprovalDecision =
-  | { kind: "allow"; scope: ApprovalScope }
-  | { kind: "deny"; reason?: string; feedback?: string }
-  | { kind: "pending"; request: ApprovalRequest };
-
-export type ApprovalResolver = (request: ApprovalRequest) => ApprovalDecision | Promise<ApprovalDecision>;
-
-export const DEFAULT_ALLOW_OPTIONS: ApprovalOption[] = [
-  { kind: "allow", scope: "once", label: "Allow once" },
-  { kind: "allow", scope: "session", label: "Allow for this session" },
-  { kind: "allow", scope: "always", label: "Always allow" },
-  { kind: "deny", label: "Deny" },
-  { kind: "feedback", label: "Deny with feedback", prompt: "Why should this be denied?" },
-];

package/src/agent/compaction.ts

@@ -1,276 +0,0 @@
-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 type { ChatMessage } from "../types.js";
-import { parseToolCalls, stripToolCalls } from "./protocol.js";
-
-export interface CompactionConfig {
-    enabled: boolean;
-    localThresholdRatio: number;
-    keepTurns: number;
-    serverCompactionAware: boolean;
-    serverCompactThreshold?: number;
-    clampAboveServerByTokens: number;
-    maxSummaryTokens: number;
-    heapLimitMb: number;
-}
-
-export const DEFAULT_COMPACTION_CONFIG: CompactionConfig = {
-    enabled: true,
-    localThresholdRatio: 0.7,
-    keepTurns: 6,
-    serverCompactionAware: false,
-    clampAboveServerByTokens: 8192,
-    maxSummaryTokens: 1500,
-    heapLimitMb: 220,
-};
-
-export interface CompactionOptions {
-    contextWindow: number;
-    providerId?: string;
-    model?: string;
-    force?: boolean;
-    serverOpaqueState?: string;
-}
-
-export interface CompactionResult {
-    messages: ChatMessage[];
-    compacted: boolean;
-    reason?: "threshold" | "heap";
-    source: "local" | "server" | "none";
-    beforeTokens: number;
-    afterTokens: number;
-    beforeChars: number;
-    afterChars: number;
-    droppedMessages: number;
-    keptMessages: number;
-    summary?: string;
-    summaryFile?: string;
-}
-
-export function compactionConfigFromEnv(): CompactionConfig {
-    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: CompactionConfig, contextWindow: number): number {
-    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: CompactionConfig): boolean {
-    const used = process.memoryUsage().heapUsed;
-    return used > Math.max(0, config.heapLimitMb) * 1024 * 1024;
-}
-
-export function shouldCompact(messages: ChatMessage[], config: CompactionConfig, options: CompactionOptions): boolean {
-    if (!config.enabled)
-        return false;
-    if (options.force || heapExceeded(config))
-        return true;
-    return messageTokens(messages, options) > localThresholdTokens(config, options.contextWindow);
-}
-
-export function compactMessages(messages: ChatMessage[], config: CompactionConfig = DEFAULT_COMPACTION_CONFIG, options: CompactionOptions): CompactionResult {
-    const beforeTokens = messageTokens(messages, options);
-    const beforeChars = messageChars(messages);
-    const heap = heapExceeded(config);
-    const noop: CompactionResult = {
-        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: "threshold" | "heap" = 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: ChatMessage = {
-        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: ChatMessage[], options: CompactionOptions): number {
-    return estMessagesTokens(messages, { providerId: options.providerId, model: options.model });
-}
-
-function messageChars(messages: ChatMessage[]): number {
-    return messages.reduce((sum, message) => sum + (message.content?.length ?? 0), 0);
-}
-
-export function buildSummary(messages: ChatMessage[], config: CompactionConfig, options: Pick<CompactionOptions, "providerId" | "model">): string {
-    const requests: string[] = [];
-    const actions: string[] = [];
-    const outcomes: string[] = [];
-    const notes: string[] = [];
-    const files = new Set<string>();
-    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: string[] = [];
-    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: any): string {
-    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: string, files: Set<string>): void {
-    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: string[], max: number): string[] {
-    return lines.slice(0, max);
-}
-
-function clip(text: string, max: number): string {
-    const oneLine = String(text).replace(/\s+/g, " ").trim();
-    return oneLine.length > max ? oneLine.slice(0, max) + "…" : oneLine;
-}
-
-function writeSummaryFile(summary: string): string | undefined {
-    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/src/agent/context.ts

@@ -1,97 +0,0 @@
-/**
- * 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;
-}
-
-const TOOL_MARKER = "FastCode executed the requested local tools.";
-
-export function historyChars(messages: ChatMessage[]): number {
-    return messages.reduce((sum, message) => sum + (message.content?.length ?? 0), 0);
-}
-
-export function compactHistory(messages: ChatMessage[], options: CompactOptions = {}): CompactResult {
-    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: ChatMessage = {
-        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: string, limit: number): string {
-    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: string, limit: number): string {
-    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: number | undefined, fallback: number): number {
-    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
-}

package/src/agent/ignore.ts

@@ -1,147 +0,0 @@
-/**
- * Ignore rules for directory walks and reads.
- *
- * Defaults cover the usual dependency/build folders. Users can add more with
- * `.fastcodeignore` in the project root, using a gitignore-like syntax:
- *
- *   node_modules/     # trailing slash = directories only
- *   *.log             # basename at any depth
- *   /secrets.txt      # anchored to the project root
- *   !important.log    # re-include (last matching rule wins)
- */
-import { readFileSync, statSync } from "node:fs";
-import { join, relative, sep } from "node:path";
-
-const DEFAULT_NAMES = new Set([
-    "node_modules",
-    ".git",
-    ".hg",
-    ".svn",
-    "dist",
-    "build",
-    "out",
-    ".next",
-    ".nuxt",
-    ".output",
-    ".turbo",
-    ".parcel-cache",
-    ".cache",
-    "coverage",
-    ".nyc_output",
-    "__pycache__",
-    ".venv",
-    "venv",
-    "target",
-    ".gradle",
-    ".idea",
-]);
-
-const BINARY_EXT = /\.(png|jpe?g|gif|webp|ico|bmp|tiff?|pdf|zip|gz|tgz|bz2|xz|7z|rar|exe|dll|so|dylib|bin|wasm|mp3|mp4|mov|avi|mkv|wav|flac|ttf|otf|woff2?|eot|class|jar|apk|ipa|sqlite|db|lock)$/i;
-
-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 function isBinaryName(name: string): boolean {
-    return BINARY_EXT.test(name);
-}
-
-export function createIgnore(root: string): IgnoreMatcher {
-    const rules = loadRules(root);
-    return {
-        ignored(name, fullPath, isDir) {
-            if (DEFAULT_NAMES.has(name))
-                return true;
-            if (rules.length === 0)
-                return false;
-            const rel = relative(root, fullPath).split(sep).join("/");
-            let ignored = false;
-            for (const rule of rules) {
-                if (rule.dirOnly && !isDir)
-                    continue;
-                if (rule.regex.test(rel) || rule.regex.test(name))
-                    ignored = !rule.negate;
-            }
-            return ignored;
-        },
-        isBinary(name) {
-            return BINARY_EXT.test(name);
-        },
-    };
-}
-
-function loadRules(root: string): IgnoreRule[] {
-    const file = join(root, ".fastcodeignore");
-    let text = "";
-    try {
-        const info = statSync(file);
-        if (!info.isFile())
-            return [];
-        text = readFileSync(file, "utf8");
-    }
-    catch {
-        return [];
-    }
-    const rules: IgnoreRule[] = [];
-    for (const raw of text.split(/\r?\n/)) {
-        const line = raw.trim();
-        if (!line || line.startsWith("#"))
-            continue;
-        const negate = line.startsWith("!");
-        const body = negate ? line.slice(1).trim() : line;
-        if (!body)
-            continue;
-        const dirOnly = body.endsWith("/");
-        const pattern = dirOnly ? body.slice(0, -1) : body;
-        const anchored = pattern.startsWith("/");
-        const glob = anchored ? pattern.slice(1) : pattern;
-        try {
-            rules.push({
-                regex: globToRegExp(glob, anchored),
-                negate,
-                dirOnly,
-            });
-        }
-        catch {
-            // A bad pattern must not disable the whole ignore file.
-        }
-    }
-    return rules;
-}
-
-function globToRegExp(glob: string, anchored: boolean): RegExp {
-    let source = "";
-    for (let i = 0; i < glob.length; i += 1) {
-        const char = glob[i];
-        if (char === "*") {
-            if (glob[i + 1] === "*") {
-                source += ".*";
-                i += 1;
-                if (glob[i + 1] === "/")
-                    i += 1;
-            }
-            else {
-                source += "[^/]*";
-            }
-        }
-        else if (char === "?") {
-            source += "[^/]";
-        }
-        else {
-            source += escapeRegExp(char);
-        }
-    }
-    // Unanchored patterns match a basename at any depth.
-    return new RegExp("^" + (anchored ? "" : "(?:.*/)?") + source + "$");
-}
-
-function escapeRegExp(value: string): string {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}

package/src/agent/process-tree.ts

@@ -1,32 +0,0 @@
-import { spawn, type ChildProcess } from "node:child_process";
-
-export function killProcessTree(child: ChildProcess | undefined, signal: NodeJS.Signals = "SIGTERM"): void {
-  if (!child || typeof child.pid !== "number")
-    return;
-  if (process.platform === "win32") {
-    try {
-      const killer = spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { windowsHide: true, stdio: "ignore" });
-      killer.unref();
-    }
-    catch {
-      try {
-        child.kill();
-      }
-      catch {
-        // The process may already be gone.
-      }
-    }
-    return;
-  }
-  try {
-    process.kill(-child.pid, signal);
-  }
-  catch {
-    try {
-      child.kill(signal);
-    }
-    catch {
-      // Same as above.
-    }
-  }
-}

package/src/agent/protocol-mode.ts

@@ -1,59 +0,0 @@
-import { getModelMeta } from "../lib/model-meta.js";
-
-export type ToolProtocol = "legacy" | "native";
-export type ToolCapability = "native" | "pseudo";
-
-const NATIVE_PROVIDERS = new Set([
-    "openai",
-    "openrouter",
-    "deepseek",
-    "groq",
-    "mistral",
-    "xai",
-    "moonshot",
-    "zhipu",
-    "qwen",
-    "ollama",
-]);
-
-export function toolCapabilityKey(providerId: string, model: string): string {
-    return `${providerId}::${model}`;
-}
-
-export function resolveToolProtocol(config: any, providerId: string, model: string, env = process.env): ToolProtocol {
-    const mode = String(env["FASTCODE_TOOL_PROTOCOL"] ?? "legacy").trim().toLowerCase();
-    if (mode === "legacy")
-        return "legacy";
-    if (mode === "native")
-        return "native";
-    if (mode !== "auto")
-        return "legacy";
-    const cached = config?.capabilities?.toolCalling?.[toolCapabilityKey(providerId, model)];
-    if (cached === "pseudo")
-        return "legacy";
-    if (cached === "native")
-        return "native";
-    if (!NATIVE_PROVIDERS.has(providerId))
-        return "legacy";
-    return getModelMeta(providerId, model).supportsTools ? "native" : "legacy";
-}
-
-export function withToolCapability(config: any, providerId: string, model: string, capability: ToolCapability): any {
-    const key = toolCapabilityKey(providerId, model);
-    return {
-        ...config,
-        capabilities: {
-            ...(config?.capabilities ?? {}),
-            toolCalling: {
-                ...(config?.capabilities?.toolCalling ?? {}),
-                [key]: capability,
-            },
-        },
-    };
-}
-
-export function isNativeUnsupportedError(message: string): boolean {
-    return /\b400\b/.test(message)
-        && /tool|function/i.test(message)
-        && /not supported|unsupported|unrecognized|unknown|invalid|does not support/i.test(message);
-}